This specification defines a core subset of Mathematical Markup Language, or MathML, that is suitable for browser implementation. MathML is a markup language for describing mathematical notation and capturing both its structure and content. The goal of MathML is to enable mathematics to be served, received, and processed on the World Wide Web, just as HTML has enabled this functionality for text.

This is a public copy of the editors’ draft. It is provided for discussion only and may change at any moment. Its publication here does not imply endorsement of its contents by W3C. Don’t cite this document other than as work in progress.

## Introduction

The [[MATHML3]] specification has several shortcomings that make it hard to implement consistently across web rendering engines or to extend with user-defined constructions e.g.

• It is a huge and standalone specification.
• It does not contain any detailed rendering rules.
• It is not driven by browser-implementation.
• It lacks automated testing.

This MathML Core specification intends to address these issues by being as accurate as possible on the visual rendering of mathematical formulas using additional rules from the TeXBook’s Appendix G [[?TEXBOOK]] and from the Open Font Format [[OPEN-FONT-FORMAT]], [[OPEN-TYPE-MATH-ILLUMINATED]]. It also relies on modern browser implementations and web technologies [[HTML]] clarifying interactions with them when needed or introducing new low-level primitives to improve the web platform layering.

Parts of MathML3 that do not fit well in this framework or are less fundamental have been omitted. Instead, they are described in a separate and larger [[MATHML4]] specification. The details of which math feature will be included in future versions of MathML Core or implemented as polyfills is still open. This question and other potential improvements are tracked on GitHub.

By increasing the level of implementation details, focusing on a workable subset, following a browser-driven design and relying on automated web platform tests, this specification is expected to greatly improve MathML interoperability. Moreover, effort on MathML layering will enable users to implement the rest of the MathML 4 specification, or more generally to extend MathML Core, using modern web technologies such as shadow DOM, custom elements, CSS layout API or other Houdini APIs.

## MathML Fundamentals

### Elements and attributes

The term MathML element refers to any element in the MathML namespace. The MathML element defined in this specification are called the MathML Core elements and are listed below. Any MathML element that is not listed below is called an Unknown MathML element.

The grouping elements are <maction>, [itex], <merror> <mphantom>, <mprescripts>, <mrow>, <mstyle>, <none>, <semantics> and unknown MathML elements.

The scripted elements are <mmultiscripts>, <mover>, <msub>, <msubsup>, <msup>, <munder> and <munderover>.

The radical elements are <mroot> and <msqrt>.

The attributes defined in this specification have no namespace and are called MathML attributes:

#### The Top-Level `[itex]` Element

MathML specifies a single top-level or root `[itex]` element, which encapsulates each instance of MathML markup within a document. All other MathML content must be contained in a `[itex]` element.

The `[itex]` element accepts the attributes described in as well as the following attribute:

The `display` attribute, if present, must be an ASCII case-insensitive match to `block` or `inline`. The user agent stylesheet described in contains rules for this attribute that affect the default values for the `display` (`math` or `inline-math`) and `math-style` (`normal` or `compact`) properties. If the `display` attribute is absent or has an invalid value, the User Agent stylesheet treats it the same as `inline`.

If the element does not have its computed `display` property equal to `math` or `inline-math` then it is laid out according to the CSS specification where the corresponding value is described. Otherwise the layout algorithm of the `<mrow>` element is used to produce a box. That MathML box is used as the content for the layout of the element, as described by CSS for `display: block` (if the computed value is `math`) or `display: inline` (if the computed value is `inline-math`). Additionally, if the computed `display` property is equal to `math` then that MathML box is rendered horizontally centered within the content box.

TEX's display mode `\$...\$` and inline mode `\$...\$` correspond to `display="block"` and `display="inline"` respectively.

In the following example, a [itex] formula is rendered in display mode on a new line and taking full width, with the math content centered within the container:

As a comparison, the same formula would look as follows in inline mode. The formula is embedded in the paragraph of text without forced line breaking. The baselines specified by the layout algorithm of the `<mrow>` are used for vertical alignement. Note that the middle of sum and equal symbols or fractions are all aligned, but not with the alphabetical baseline of the surrounding text.

Because good mathematical rendering requires use of mathematical fonts, the user agent stylesheet should set the `font-family` to the `math` value on the `[itex]` element instead of inheriting it. Additionally, several CSS properties that can be set on a parent container such as `font-style`, `font-weight`, `direction` or `text-indent` etc are not expected to apply to the math formula and so the user agent stylesheet has rules to reset them by default.

All token elements and the mrow grouping element are potentially linkable and may contain an `href` attribute. They are the MathML equivalents of HTML's a and must follow all of the same criteria laid out for links there.

#### Types for MathML Attribute Values

unsigned-integer
An `<integer-value>` value as defined in [[CSS-VALUES-3]], whose first character is neither U+002D HYPHEN-MINUS character (-) nor U+002B PLUS SIGN (+).
length-percentage
A `<length-percentage>` value as defined in [[CSS-VALUES-3]]
color
A `<color>` value as defined in [[CSS-COLOR-3]]
boolean
A string that is an ASCII case-insensitive match to `true` or `false`.

#### Global Attributes

The following attributes are common to and may be specified on all MathML elements:

#### Attributes common to HTML and MathML elements

The `id`, `class`, `style`, `data-*`, `nonce` and `tabindex` attributes have the same syntax and semantic as defined for id, class, style, data-*, nonce and tabindex attributes on HTML elements.

The `href` attribute has the same syntax and semantic as defined for the href attribute on `<a>` element. To fully implement this attribute, the following CSS properties for links must be specified in the user agent stylesheet:

The `dir` attribute, if present, must be an ASCII case-insensitive match to `ltr` or `rtl`. In that case, the user agent is expected to treat the attribute as a presentational hint setting the element's `direction` property to the corresponding value. This attribute is used to set the directionality of math formulas, which is often `rtl` in Arabic speaking world.

In the following example, the dir attribute is used to render "𞸎 plus 𞸑 raised to the power of (٢ over, 𞸟 plus ١)" from right-to-left.

All MathML elements support event handler content attributes, as described in event handler content attributes in HTML.

All event handler content attributes noted by HTML as being supported by all HTMLElements are supported by all MathML elements as well, as defined in the MathMLElement IDL.

#### Legacy MathML Style Attributes

The `mathcolor` and `mathbackground` attributes, if present, must have a value that is a color. In that case, the user agent is expected to treat these attributes as a presentational hint setting the element's `color` and `background-color` properties to the corresponding values. The `mathcolor` attribute describes the foreground fill color of MathML text, bars etc while the `mathbackground` attribute describes the background color of an element.

The `mathsize` attribute, if present, must have a value that is a valid length-percentage. In that case, the user agent is expected to treat the attribute as a presentational hint setting the element's `font-size` property to the corresponding value. The `mathsize` property indicates indicates the desired height of glyphs in math formulas but also scale other parts (spacing, shifts, line thickness of bars etc) accordingly.

The above attributes are implemented for compatibility with full MathML. Authors whose only target is MathML Core are encouraged to use CSS for styling.

#### The `mathvariant` attribute

The `mathvariant` attribute, if present, must be an ASCII case-insensitive match to one of: `normal`, `bold`, `italic`, `bold-italic`, `double-struck`, `bold-fraktur`, `script`, `bold-script`, `fraktur`, `sans-serif`, `bold-sans-serif`, `sans-serif-italic`, `sans-serif-bold-italic`, `monospace`, `initial`, `tailed`, `looped`, or `stretched`. In that case, the user agent is expected to treat the attribute as a presentational hint setting the element's `text-transform` property to the corresponding value. More precisely, `normal` is mapped to `none` while all the other values are mapped to the corresponding CSS value with the extra `math-` prefix.

The `mathvariant` attribute defines logical classes of token elements. Each class provides a collection of typographically-related symbolic tokens with specific meaning within a given mathematical expression. For `mathvariant` values other than `normal`, this is done by using glyphs of Unicode's Mathematical Alphanumeric Symbols.

In the following example, the mathvariant attribute is used to render different A letters. Note that by default variables use mathematical italic.

`mathvariant` values other than `normal` are implemented for compatibility with full MathML and legacy editors that can't access characters in Plane 1 of Unicode. Authors are encouraged to use the corresponding Unicode characters. The `normal` value is still important to cancel automatic italic of the `<mi>` element.
Unicode does not distinguish between Chancery and Spencerian style for the Unicode MATHEMATICAL SCRIPT characters. However, some mathematical fonts rely on `salt` or `ssXY` properties from [[OPEN-FONT-FORMAT]] to provide both styles. Page authors may use the `font-variant-alternates` property with corresponding OpenType font features to access these glyphs.

#### The `displaystyle` and `scriptlevel` attributes

The `displaystyle` attribute, if present, must have a value that is a boolean. In that case, the user agent is expected to treat the attribute as a presentational hint setting the element's `math-style` property to the corresponding value. More precisely, `true` is mapped to `normal` and `false` to `compact`. This attribute indicates whether formulas should try to minimize the logical height (value is `false`) or not (value is `true`) e.g. by changing the size of content or the layout of scripts.

The `scriptlevel` attribute, if present, must have value `+<U>`, `-<U>` or `<U>` where `<U>` is an unsigned-integer. In that case and if the mathsize attribute is absent, the user agent is expected to treat the `scriptlevel` attribute as a presentational hint setting the element's `font-size` property to the corresponding value. More precisely, `+<U>`, `-<U>` and `<U>` are respectively mapped to `scriptlevel(add(<U>))` `scriptlevel(add(<-U>))` and `scriptlevel(<U>)`.

`displaystyle` and `scriptlevel` values are automatically adjusted within MathML elements. To fully implement these attributes, additional CSS properties must be specified in the user agent stylesheet as described in .

In this example, a <munder> element is used to attach a script "A" attached to a base "∑". By default, the summation symbol is rendered with the font-size inherited from its parent and the A as a scaled down subscript. If displaystyle is true, the summation symbol is drawn bigger and the "A" becomes an underscript. If scriptlevel is reset to 0 on the "A", then it will use the same font-size as the top-level `math` root.

TEX's `\displaystyle`, `\textstyle`, `\scriptstyle`, and `\scriptscriptstyle` correspond to `displaystyle` and `scriptlevel` as `true` and `0`, `false` and `0`, `false` and `1`, and `false` and 2, respectively.

### Integration in the Web Platform

#### HTML and SVG

When parsing HTML documents user agents must treat any tag name corresponding to a MathML Core Element as belonging to the MathML namespace.

Users agents must allow mixing HTML, SVG and MathML elements as allowed by sections HTML integration point, MathML integration point, tree construction dispatcher, MathML and SVG from [[HTML]].

When evaluating the SVG `requiredExtensions` attribute, user agents must claim support for the language extension identified by the MathML namespace.

In this example, inline MathML and SVG elements are used inside a HTML document. SVG elements `<switch>` and `<foreignObject>` (with proper `<requiredExtensions>`) are used to embed a MathML formula with a text fallback, inside a diagram. HTML `input` element is used within the <mtext> include an interactive input field inside a mathematical formula.

#### CSS styling

User agents must support various CSS features mentioned in this specification, including new ones described in . They must follow the computation rule for display: contents.

In this example, the MathML formula inherits the CSS color of its parent and uses the `font-family` specified via the style attribute.

All documents containing MathML Core elements must include CSS rules described in as part of user-agent level style sheet defaults.

The following CSS features are not supported and must be ignored:

• Vertical math layout: `writing-mode` is treated as `horizontal-tb` on all MathML elements.
• Line breaking inside math formulas: `white-space` is treated as `nowrap` on all MathML elements.
• Sizes: `width`, `height`, `inline-size` and `block-size` are treated as `auto` on elements with computed display value `math` or `inline-math`.
• Floats: `float` and `clear` are treated as `none` on all MathML elements.
• Alignment properties: `align-content`, `justify-content`, `align-self`, `justify-self` have no effect on MathML elements.
These features might be handled in future versions of this document. For now, authors are discouraged from setting a different value for these properties as that might lead to backward incompatibility issues.

#### DOM and Javascript

User agents supporting Web application APIs must ensure that they keep the visual rendering of MathML in synchronization with the [[DOM]] tree.

All the nodes representing MathML elements in the DOM must implement, and expose to scripts, the following `MathMLElement` interface.

The `GlobalEventHandlers`, `DocumentAndElementEventHandlers` and `HTMLOrForeignElement` interfaces are defined in [[HTML]].

The `ElementCSSInlineStyle` interface is defined in [[CSSOM]].

Each IDL attribute of the `MathMLElement` interface reflects the corresponding MathML content attribute.

In the following example, a MathML formula is used to render the fraction "α over 2". When clicking the red α, it is changed into a blue β.

All of the nodes representing MathML Hyperlink Elements in the DOM must implement, and expose to scripts the following `MathMLLinkableElement` interface.

Specialize unknown MathML elements to a `MathMLUnknownElement` interface?
Rename HTMLOrSVGElement and define MathMLElement in [[HTML]].
Move `HTMLElement includes ElementCSSInlineStyle;` to the [[CSSOM]] specification.

#### Text layout

Because math fonts generally contain very tall glyphs such as big integrals, using typographic metrics is important to avoid excessive line spacing of text. As a consequence, user agents must take into account the USE_TYPO_METRICS flag from the OS/2 table [[OPEN-FONT-FORMAT]] when performing text layout.

#### Focus

MathML provides the ability for authors to allow for interactivity in supporting interactive user agents using the same concepts, approach and guidance to `Focus` as described in HTML, with modifications or clarifications regarding application for MathML as described in this section.

When an element is focused, all applicable CSS focus-related pseudo-classes as defined in CSS Selectors apply, as defined in that specification.

All `MathMLLinkableElement` elements are potentially linkable with an `href` attribute. Their default tabindex is `0`. If their `href` contains a valid URL, their focus flag must be set unless the user agent normally provides an alternative method of keyboard traversal of links, and they appear in the sequential focus order.

The contents of embedded `[itex]` elements (including HTML elements inside token elements), contribute to the sequential focus order of the containing owner HTML document (combined sequential focus order).

## Presentation Markup

### Visual formatting model

#### Box Model

The default `display` property is described in :

In order to specify math layout in different writing modes, this specification uses concepts from [[CSS-WRITING-MODES-3]]:

Unless specified otherwise, the figures in this specification use a writing mode of `horizontal-lr` and `ltr`. See , and for examples of other writing modes that are sometimes used for math layout.

MathML boxes have several parameters in order to perform layout in a way that is compatible with CSS but also to take into account very accurate positions and spacing within math formulas. Each math box has the following parameters:

1. Inline metrics. min-content inline size, max-content inline size and inline size from CSS. See .
2. Block metrics. The block size, first baseline set and last baseline set. The following baselines are defined for MathML boxes:

1. The alphabetic baseline which typically aligns with the bottom of uppercase Latin glyphs. The algebric distance from the alphabetic baseline to the line-over edge of the box is the called line-ascent. The algebric distance from the line-under edge to the alphabetic baseline of the box is the called line-descent.
2. The mathematical baseline also called math axis which typically aligns with the fraction bar, middle of fences and binary operators. It is shifted away from the alphabetic baseline by AxisHeight towards the line-over.
3. The ink-over baseline, indicating the line-over theorical limit of the content drawn, excluding any extra space. If not specified, it is aligned with the line-over edge. The algebric distance from the alphabetic baseline to the ink-over baseline is called the ink line-ascent.
4. The ink-under baseline, indicating the line-under theorical limit of the content drawn, excluding any extra space. If not specified, it is aligned with the line-under edge. The algebric distance from the ink-under baseline to the alphabetic baseline is called the ink line-descent.
For math layout, it is very important to rely on the ink extent when positioning text. This is not the case for more complex notations (e.g. square root). Although ink-ascent and ink-descent are defined for all MathML elements they are really only used for the token elements. In other cases, they just match normal ascent and descent.
Unless specified otherwise, the last baseline set is equal to the first baseline set for MathML boxes.
3. An optional italic correction which provides a measure of how much the text of a box is slanted along the inline axis. See . If it is requested during calculation of min-content inline size and max-content inline size or during layout then 0 is used as a fallback value.
4. An optional top accent attachment which provides a reference offset on the inline axis of a box that should be used when positioning that box as an accent. See . If it is requested during calculation of min-content inline size (respectively max-content inline size) then half the min-content inline size (respectively max-content inline size) is used as a fallback value. If it is requested during layout then half the inline size of the box is used as a fallback value.

Given a MathML box, the inline offset of a child box is the distance between the inline-start edge of the parent box and the inline-start edge of the child box. The block offset of a child box is the offset between block-start edge of the parent box and the block-start edge of the child box.

The line-left offset, line-right offset, line-over offset and line-under offset are defined similarly as offsets between the corresponding parent and child edges.

The position of child boxes and graphical items inside a MathML box are expressed using the inline offset and block offset. For convenience, the layout algorithms may describe offsets using flow-relative directions, line-relative directions or the alphabetic baseline. It is always possible to pass from one description to the other because position of child boxes are always performed after the metrics of the box and of its child boxes are calculated.

Here are examples of offsets obtained from line-relative metrics:

Improve definition of ink ascent/descent?

#### Layout Algorithms

The layout algorithms described in this chapter for MathML boxes have the following structure:

1. Calculation of min-content inline size and max-content inline size of the content.
2. Box layout:
1. Layout of in-flow child boxes.
2. Calculation of inline size, ink line-ascent, ink line-descent, line-ascent and line-ascent of the content.
3. Calculation of offsets of child boxes within the content box as well as sizes and offsets of extra graphical items (bars, radical symbol, etc).
4. Layout and positioning of out-of-flow child boxes.

During box layout, the following extra steps must be performed:

Per the description above, margin-collapsing does not apply to MathML elements.

During box layout, optional inline stretch size constraint and block stretch size constraint parameters may be used on embellished operators. The former indicates a target size that a core operator stretched along the inline axis should cover. The latter indicates an ink line-ascent and ink line-descent that a core operator stretched along the block axis should cover. Unless specified otherwise, these parameters are ignored during box layout and child boxes are laid out without any stretch size constraint.

Explain how out-of-flow elements are positioned.
Interpret width/height/inline-size/block-size?
Define what inline percentages resolve against
Define what block percentages resolve against

#### Stacking contexts

MathML elements can overlap due to various spacing rules. They can as well contain extra graphical items (bars, radical symbol, etc). A MathML element with computed style `display: math` or `display: inline-math` generates a new stacking context. The painting order of in-flow children of such a MathML element is exactly the same as block elements. The extra graphical items are painted after text and background (right after step 7.2.4 for `display: inline-math` and right after step 7.2 for `display: math`).

### Token Elements

Token elements in presentation markup are broadly intended to represent the smallest units of mathematical notation which carry meaning. Tokens are roughly analogous to words in text. However, because of the precise, symbolic nature of mathematical notation, the various categories and properties of token elements figure prominently in MathML markup. By contrast, in textual data, individual words rarely need to be marked up or styled specially.

In practice, most MathML token elements just contain simple text for variables, numbers, operators etc and don't need sophisticated layout. However, it can contain contain text with line breaks or arbitrary HTML5 phrasing elements.

#### Text `<mtext>`

The `<mtext>` element is used to represent arbitrary text that should be rendered as itself. In general, the `<mtext>` element is intended to denote commentary text.

The `<mtext>` element accepts the attributes described in .

In the following example, <mtext> is used to put conditional words in a definition:

#### Layout of `<mtext>`

If the element does not have its computed `display` property equal to `math` or `inline-math` then it is laid out according to the CSS specification where the corresponding value is described. Otherwise, the layout below is performed.

The `mtext` element is laid out as a block box and the min-content inline size, max-content inline size, inline size, block size, first baseline set and last baseline set are determined accordingly.

If the `<mtext>` element contains only text content without forced line break or soft wrap opportunity then in addition:

#### Identifier `<mi>`

The `<mi>` element represents a symbolic name or arbitrary text that should be rendered as an identifier. Identifiers can include variables, function names, and symbolic constants.

The `<mi>` element accepts the attributes described in . Its layout algorithm is the same as the <mtext> element. The user agent stylesheet must contain the following property in order to implement automatic italic:

In the following example, <mi> is used to render variables and function names. Note that identifiers containing a single letter are italic by default.

#### Number `<mn>`

The `<mn>` element represents a "numeric literal" or other data that should be rendered as a numeric literal. Generally speaking, a numeric literal is a sequence of digits, perhaps including a decimal point, representing an unsigned integer or real number.

The `<mn>` element accepts the attributes described in . Its layout algorithm is the same as the `<mtext>` element.

In the following example, <mn> is used to write a decimal number.

#### Operator, Fence, Separator or Accent `<mo>`

The `<mo>` element represents an operator or anything that should be rendered as an operator. In general, the notational conventions for mathematical operators are quite complicated, and therefore MathML provides a relatively sophisticated mechanism for specifying the rendering behavior of an `<mo>` element.

As a consequence, in MathML the list of things that should "render as an operator" includes a number of notations that are not mathematical operators in the ordinary sense. Besides ordinary operators with infix, prefix, or postfix forms, these include fence characters such as braces, parentheses, and "absolute value" bars; separators such as comma and semicolon; and mathematical accents such as a bar or tilde over a symbol. This chapter uses the term "operator" to refer to operators in this broad sense.

The `<mo>` element accepts the attributes described in as well as the following attributes:

This specification does not define any observable behavior that is specific to the fence and separator attributes.

Authors may use the `fence` and `separator` to describe specific semantics of operators. The default values may be determined from the `Operators_fence` and `Operators_separator` tables, or equivalently the human-readable version of the operator dictionary.

In the following example, the <mo> element is used for the binary operator +. Default spacing is symmetric around that operator. A tigher spacing is used if you rely on the `form` attribute to force it to be treated as a prefix operator. Spacing can also be specified explicitly using the `lspace` and `rspace` attributes.

Another use case is for big operator such as summation. When displaystyle is true, such an operator are drawn larger but one can change that with the largeop attribute. When displaystyle is false, underscript are actually rendered as subscript but one can change that with the movablelimits attribute.

Operators are also used for stretchy symbols such as fences, accents, arrows etc. In the following example, the vertical arrow stretches to the height of the <mspace> element. One can override default stretch behavior with the stretchy attribute e.g. to force an unstretched arrow. The symmetric attribute allows to indicate whether the operator should stretchy symmetrically above and below the baseline. Finally the minsize and maxsize attributes add additional constraints over the stretch size.

Note that the default properties of operators are dictionary-based, as explained in . For example a binary operator typically has default symmetric spacing around it while a fence is generally stretchy by default.

##### Embellished operators

A MathML Core element is an embellished operator if is is:

1. An `<mo>` element;
2. A scripted element or an `<mfrac>`, whose first in-flow child exists and is an embellished operator;
3. A grouping element or <mpadded>, whose in-flow children consist (in any order) of one embellished operator and zero or more space-like elements.

The core operator of an embellished operator is the `<mo>` element defined recursively as follows:

1. The core operator of an `<mo>` element; is the element itself.
2. The core operator of an embellished scripted element or `<mfrac>` element is the core operator of its first in-flow child.
3. The core operator of an embellished grouping element or <mpadded> is the core operator of its unique embellished operator in-flow child.

The stretch axis of an embellished operator is inline if its core operator contains only text content made of a unique character `c` and that character has stretch axis inline per . Otherwise, stretch axis of the embellished operator is block.

#### Dictionary-based attributes

The `form` property of an embellished operator is either `infix`, `prefix` or `postfix`. The corresponding `form` attribute on the `<mo>` element, if present, must must be an ASCII case-insensitive match to one of these values.

The `form` of an embellished operator is determined as follows:

1. If the `form` attribute is present and valid on the core operator, then its value is used;
2. If the embellished operator is the first in-flow child of a grouping element, <mpadded> or <msqrt> with more than one in-flow child (ignoring all space-like children) then it has form `prefix`;
3. Or, if the embellished operator is the last in-flow child of a grouping element, `<mpadded>` or `<msqrt>` with more than one in-flow child (ignoring all space-like children) then it has form `postfix`;
4. Or, if the embellished operator is an in-flow child of a scripted element, other than the first in-flow child, then it has form `postfix`;
5. Otherwise, the embellished operator has form `infix`.

The `stretchy`, `symmetric`, `largeop`, `movablelimits`, properties of an embellished operator are either `false` or `true`. In the latter case, it is said that the embellished operator has the property. The corresponding attributes on the `<mo>` element, if present, must be a boolean.

The `lspace`, `rspace`, `minsize` properties of an embellished operator are length-percentage. The `maxsize` property of an embellished operator is either a length-percentage or ∞. The `lspace`, `rspace`, `minsize` and `maxsize` attributes on the `<mo>` element, if present, must be a length-percentage.

The `stretchy`, `symmetric`, `largeop`, `movablelimits`, `lspace`, `rspace`, `maxsize`, `minsize` properties of an embellished operator are determined as follows:

1. If the corresponding attribute is present and valid on the core operator, then this property is used;
2. Otherwise, if the core operator contains only text content T, the corresponding property from the Operator Dictionary is retrieved by looking for `Content=T,Form=F` where `F` is the `form` of the embellished operator;
3. If no entry is found and the `form` of embellished operator was not explicitly specified as an attribute on its core operator, then user agents must try other dictionary entries for different values of `F` in the following order: `infix`, `prefix`, `postfix`;
4. Otherwise, use the value `false` for `stretchy`, `symmetric`, `largeop` and `movablelimits` properties ; `0.2777777777777778em` for `lspace` and `rspace` properties ; `100%` for the `minsize` property and ∞ for the `maxsize` property.

Percentage values for `lspace`, `rspace` properties of an embellished operator are interpreted relative to the value read from the dictionary or to the fallback value above.

Percentages value for `minsize` and `maxsize` properties of an embellished operator are interpreted relative to the target stretch size before application of size constraints, as described in .

Font-relative lengths for `lspace`, `rspace`, `minsize` and `maxsize` rely on the font style of the core operator, not the one of the embellished operator.

#### Layout of operators

If the `<mo>` element does not have its computed `display` property equal to `math` or `inline-math` then it is laid out according to the CSS specification where the corresponding value is described. Otherwise, the layout below is performed.

The text of the operator must only be painted if the `visibility` of the `<mo>` element is `visible`. In that case, it must be painted with the `color` of the `<mo>` element.

Operators are laid out as follows:

1. If the content of the `<mo>` element is not made of a single character `c` then fallback to the layout algorithm of .
2. If the operator has the stretchy property:
• If the stretch axis of the operator is inline then
1. If it is not possible to shape a stretchy glyph corresponding to `c` in the inline direction with the current font then fallback to the layout algorithm of .
2. The min-content inline size and max-content inline size of the content are set to the one obtained by the layout algorithm of .
3. If there is not any inline stretch size constraint `Tinline` then fallback to the layout algorithm of .
4. The inline size and (ink) block metrics of the content are given by algorithm to shape a stretchy glyph to inline dimension `Tinline`.
5. The painting of the operator is performed by the algorithm to shape a stretchy glyph stretched to inline dimension `Tinline` and at position determined by the previous box metrics.
• Otherwise, the stretch axis of the operator is block. The following steps are performed:
1. If it is not possible to shape a stretchy glyph corresponding to `c` in the block direction with the current font then fallback to the layout algorithm of .
2. The min-content inline size and max-content inline size of the content are set to the preferred inline size of a glyph stretched along the block axis.
3. If there is not any block stretch size constraint `(Uascent, Udescent)` then fallback to the layout algorithm of .
4. If the operator has the symmetric property then set the target sizes `Tascent` and `Tdescent` to `Sascent` and `Sdescent` respectively: Otherwise set them to `Uascent` and `Udescent` respectively.
5. Let `minsize` and `maxsize` be the minsize and maxsize properties on the operator. Percentage values are intepreted relative to `T` = `Tascent` + `Tdescent`. If `minsize` < 0 then set `minsize` to 0. If `maxsize` < `minsize` then then set `maxsize` to `minsize`. Then 0 ≤ `minsize``maxsize`:
• If `T` = 0 then set `Tascent` and `Tdescent` to `minsize`/2.
• Otherwise, if 0 < `T` < `minsize` then first multiply `Tascent` by `minsize` / `T` and then set `Tdescent` to `minsize` - `Tascent`.
• Otherwise, if `maxsize` < `T` then first multiply `Tascent` by `maxsize` / `T` and then set `Tdescent` to `maxsize``Tascent`.
6. The inline size, ink line-ascent, ink line-descent, line-ascent and line-descent of the content are obtained by the algorithm to shape a stretchy glyph to block dimension `Tascent` + `Tdescent`. The inline size of the content is the width of the stretchy glyph. The stretchy glyph is shifted towards the line-under by a value Δ so that its center aligns with the center of the target: the ink ascent of the content is the ascent of the stretchy glyph − Δ and the ink descent of the content is the descent of the stretchy glyph + Δ. These centers have coordinates "½(ascent − descent)" so Δ = [(ascent of stretchy glyph − descent of stretchy glyph) − (`Tascent``Tdescent`)] / 2.
7. The painting of the operator is performed by the algorithm to shape a stretchy glyph stretched to block dimension `Tascent` + `Tdescent` and at position determined by the previous box metrics shifted by Δ towards the line-over.
3. If the operator has the largeop property and if `math-style` on the `<mo>` element is `normal`, then:
1. Use the `MathVariants` table to try and find a glyph of height at least DisplayOperatorMinHeight If none is found, fallback to the largest non-base glyph. If none is found, fallback to the layout algorithm of .

2. The min-content inline size, max-content inline size, inline size and block metrics of the content are given by the glyph found.
3. Paint the glyph.
4. Other fallback to the layout algorithm of .

If the algorithm to shape a stretchy glyph has been used for one of the step above, then the italic correction of the content is set to the value returned by that algorithm.

If `maxsize` is equal to its default value ∞ then `minsize ≤ maxsize` is satisfied but `maxsize < T` is not.

#### Space `<mspace>`

The `<mspace>` empty element represents a blank space of any desired size, as set by its attributes.

The `<mspace>` element accepts the attributes described in as well as the following attributes:

The `mspace@width`, `mspace@height`, `mspace@depth`, if present, must have a value that is a valid length-percentage. An unspecified attribute, a percentage value, or an invalid value is interpreted as `0`. If one of the requested values calculated is negative then it is treated as `0`.

In the following example, <mspace> is used to force spacing within the formula (a 1px blue border is added to easily visualize the space):

If the `<mspace>` element does not have its computed `display` property equal to `math` or `inline-math` then it is laid out according to the CSS specification where the corresponding value is described. Otherwise, the `<mspace>` element is laid out as shown on . The min-content inline size and max-content inline size of the content are equal to the requested inline size. The inline size, line-ascent and line-descent of the content are respectively the requested inline size, line-ascent and line-descent.

The terminology height/depth comes from [[MATHML3]], itself inspired from [[TEXBOOK]].

### Definition of space-like elements

A number of MathML presentation elements are "space-like" in the sense that they typically render as whitespace, and do not affect the mathematical meaning of the expressions in which they appear. As a consequence, these elements often function in somewhat exceptional ways in other MathML expressions.

A MathML Core element is a space-like element if is is:

Note that an `<mphantom>` is not automatically defined to be space-like, unless its content is space-like. This is because operator spacing is affected by whether adjacent elements are space-like. Since the `<mphantom>` element is primarily intended as an aid in aligning expressions, operators adjacent to an `<mphantom>` should behave as if they were adjacent to the contents of the `<mphantom>`, rather than to an equivalently sized area of whitespace.

#### String Literal `<ms>`

`<ms>` element is used to represent "string literals" in expressions meant to be interpreted by computer algebra systems or other systems containing "programming languages".

The `<ms>` element accepts the attributes described in . Its layout algorithm is the same as the `<mtext>` element.

In the following example, <ms> is used to write a literal string of characters:

In MathML3, it was possible to use the `lquote` and `rquote` attributes to respectively specify the strings to use as opening and closing quotes. These are no longer supported and the quotes must instead be specified as part of the text of the `<ms>` element. One can add CSS rules to legacy documents in order to preserve visual rendering. For example, in left-to-right direction:

### General Layout Schemata

Besides tokens there are several families of MathML presentation elements. One family of elements deals with various "scripting" notations, such as subscript and superscript. Another family is concerned with matrices and tables. The remainder of the elements, discussed in this section, describe other basic notations such as fractions and radicals, or deal with general functions such as setting style properties and error handling.

#### Group Sub-Expressions `<mrow>`

The `<mrow>` element is used to group together any number of sub-expressions, usually consisting of one or more `<mo>` elements acting as "operators" on one or more other expressions that are their "operands".

In the following example, <mrow> is used to group a sum "1 + 2/3" as a fraction numerator (first child of <mfrac>) and to construct a fenced expression (first child of <msup>) that is raised to the power of 5. Note that <mrow> alone does not add visual fences around its grouped content, one has to explicitly specify them using the <mo> element.

Within the <mrow> elements, one can see that vertical alignment of children (according to the alphabetic baseline or the mathematical baseline) is properly performed, fences are vertically stretched and spacing around the binary + operator automatically calculated.

The `<mrow>` element accepts the attributes described in . An `<mrow>` element with in-flow children child1, child2, … childN is laid out as show on . The child boxes are put in a row one after the other with all their alphabetic baselines aligned.

Because the box model ensure alignment of alphabetic baselines, fraction bars or symmetric stretchy operators will also be aligned along the math axis in the typical case when AxisHeight is the same for all in-flow children.
##### Algorithm for stretching operators along the block axis

The algorithm for stretching operators along the block axis consists in the following steps:

1. If there is a block stretch size constraint or an inline stretch size constraint then the element being laid out is an embellished operator. Layout the one in-flow child that is an embellished operator with the same stretch size constraint and all the other in-flow children without any stretch size constraint and stop.
2. Otherwise, split the list of in-flow children into a first list `LToStretch` containing embellished operators with a stretchy property and block stretch axis ; and a second list `LNotToStretch`.
3. Perform layout without any stretch size constraint on all the items of `LNotToStretch`. If `LToStretch` is empty then stop. If `LNotToStretch` is empty, perform layout with stretch size constraint 0 on all the items of `LToStretch`.
4. Calculate the unconstrained target sizes `Uascent` and `Udescent` as respectively the maximum ink ascent and maximum ink descent of the margin boxes of in-flow children that have been laid out in the previous step.
5. Layout or relayout all the elements of `LToStretch` with block stretch size constraint `(Uascent, Udescent)`.
##### Layout of `<mrow>`

If the element does not have its computed `display` property equal to `math` or `inline-math` then it is laid out according to the CSS specification where the corresponding value is described. Otherwise, the layout below is performed.

A child box is slanted if it is not an embellished operator and has nonzero italic correction.

Large operators may have nonzero italic correction but that one is used when attaching scripts. More generally, all embellished operator are treated as non-slanted since the spacing is designed to around them as specifed by `lspace` and `rspace`.

The min-content inline size (respectively max-content inline size) are calculated using the following algorithm:

1. Set `add-space` to true if the element is a [itex] or is not an embellished operator; and to false otherwise.
2. Set `inline-offset` to 0.
3. Set `previous-italic-correction` to 0.
4. For each in-flow child:
1. If the child is not slanted, then increment `inline-offset` by `previous-italic-correction`.
2. If the child is an embellished operators and `add-space` is true then increment `inline-offset` by its `lspace` property.
3. Increment `inline-offset` by the min-content inline size (respectively max-content inline size) of the child's margin box.
4. If the child is slanted then set `previous-italic-correction` to its italic correction. Otherwise set it to 0.
5. If the child is an embellished operators and `add-space` is true then increment `inline-offset` by its `rspace` property.
5. Increment `inline-offset` by `previous-italic-correction`.
6. Return `inline-offset`.

The in-flow children are laid out using the algorithm for stretching operators along the block axis.

The inline size of the content is calculated like the min-content inline size and max-content inline size of the content, using the inline size of the in-flow children's margin boxes instead.

The ink line-ascent (respectively line-ascent) of the content is the maximum of the ink line-ascents (respectively line-ascents) of all the in-flow children's margin boxes. Similarly, the ink line-descent (respectively line-descent) of the content is the maximum of the ink line-descents (respectively ink line-ascents) of all the in-flow children's margin boxes.

The in-flow children are positioned using the following algorithm:

1. Set `add-space` to true if the element is a [itex] or is not an embellished operator; and to false otherwise.
2. Set `inline-offset` to 0.
3. Set `previous-italic-correction` to 0.
4. For each in-flow child:
1. If the child is not slanted, then increment `inline-offset` by `previous-italic-correction`.
2. If the child is an embellished operators and `add-space` is true then increment `inline-offset` by its `lspace` property.
3. Set the inline offset of the child to `inline-offset` and its block offset such that the alphabetic baseline of the child is aligned with the alphabetic baseline.
4. Increment `inline-offset` by the inline size of the child's margin box.
5. If the child is slanted then set `previous-italic-correction` to its italic correction. Otherwise set it to 0.
6. If the child is an embellished operators and `add-space` is true then increment `inline-offset` by its `rspace` property.

The italic correction of the content is set to the italic correction of the last in-flow child, which is the final value of `previous-italic-correction`.

#### Fractions `<mfrac>`

The `<mfrac>` element is used for fractions. It can also be used to mark up fraction-like objects such as binomial coefficients and Legendre symbols.

If the `<mfrac>` element does not have its computed `display` property equal to `math` or `inline-math` then it is laid out according to the CSS specification where the corresponding value is described. Otherwise, the layout below is performed.

The `<mfrac>` element accepts the attributes described in as well as the following attribute:

The `linethickness` attribute indicates the fraction line thickness to use for the fraction bar. If present, it must have a value that is a valid length-percentage. If the attribute is absent or has an invalid value, FractionRuleThickness is used as the default value. A percentage is interpreted relative to that default value. A negative value is interpreted as 0.

The following example contains four fractions with different linethickness values. The bars are always aligned with the middle of plus and minus signs. The numerator and denominator are horizontally centered. The fractions that are not in displaystyle use smaller gaps and font-size.

The `<mfrac>` element sets `displaystyle` to `false`, or if it was already `false` increments `scriptlevel` by 1, within its children. It sets math-shift to `compact` within its second child. To avoid visual confusion between the fraction bar and another adjacent items (e.g. minus sign or another fraction's bar), a default 1-pixel space is added around the element. The user agent stylesheet must contain the following rules:

If the `<mfrac>` element has less or more than two in-flow children, its layout algorithm is the same as the `<mrow>` element. Otherwise, the first in-flow child is called numerator, the second in-flow child is called denominator and the layout algorithm is explained below.

In practice, an `<mfrac>` element has two children that are in-flow. Hence the CSS rules basically performs `scriptlevel`, `displaystyle` and math-shift changes for the numerator and denominator.
##### Fraction with nonzero line thickness

If the fraction line thickness is nonzero, the `<mfrac>` element is laid out as shown on . The fraction bar must only be painted if the `visibility` of the `<mfrac>` element is `visible`. In that case, the fraction bar must be painted with the `color` of the `<mfrac>` element.

The min-content inline size (respectively max-content inline size) of content is the maximum between the min-content inline size (respectively max-content inline size) of the numerator's margin box and the min-content inline size (respectively max-content inline size) of the denominator's margin box.

If there is an inline stretch size constraint or a block stretch size constraint then the numerator is also laid out with the same stretch size constraint otherwise it is laid out without any stretch size constraint. The denominator is always laid out without any stretch size constraint.

The inline size of the content is the maximum between the inline size of the numerator's margin box and the inline size of the denominator's margin box.

`NumeratorShift` is the maximum between:

`DenominatorShift` is the maximum between:

The line-ascent of the content is the maximum between:

The line-descent of the content is the maximum between:

The inline offset of the numerator (respectively denominator) is the half the inline size of the content − half the inline size of the numerator's margin box (respectively denominator's margin box).

The alphabetic baseline of the numerator (respectively denominator) is shifted away from the alphabetic baseline by a distance of `NumeratorShift` (respectively `DenominatorShift` ) towards the line-over (respectively line-under).

The inline size of the fraction bar is the inline size of the content and its inline offset is 0. The center of the fraction bar is shifted away from the alphabetic baseline by a distance of AxisHeight towards the line-over. Its block size is the fraction line thickness.

##### Fraction with zero line thickness

If the fraction line thickness is zero, the `<mfrac>` element is instead laid out as shown on .

The min-content inline size, max-content inline size and inline size of the content are calculated the same as in .

If there is an inline stretch size constraint or a block stretch size constraint then the numerator is also laid out with the same stretch size constraint and otherwise it is laid out without any stretch size constraint. The denominator is always laid out without any stretch size constraint.

If the math-style is `compact` then `TopShift` and `BottomShift` are respectively set to StackTopShiftUp and StackBottomShiftDown. Otherwise math-style is `normal` and they are respectively set to StackTopDisplayStyleShiftUp and StackBottomDisplayStyleShiftDown.

The `Gap` is defined to be (`BottomShift` − the ink line-ascent of the denominator's margin box) + (`TopShift` − the ink line-descent of the numerator's margin box). If math-style is `compact` then `GapMin` is StackGapMin otherwise math-style is `normal` and it is StackDisplayStyleGapMin. If Δ = `GapMin``Gap` is positive then `TopShift` and `BottomShift` are respectively increased by Δ/2 and Δ − Δ/2.

The line-ascent of the content is the maximum between:

The line-descent of the content is the maximum between:

The inline offsets of the numerator and denominator are calculated the same as in .

The alphabetic baseline of the numerator (respectively denominator) is shifted away from the alphabetic baseline by a distance of `TopShift` (respectively − `BottomShift`) towards the line-over (respectively line-under).

#### Radicals `<msqrt>`, `<mroot>`

The `<msqrt>` and `<mroot>` elements construct radicals. The `<msqrt>` element is used for square roots, while the `<mroot>` element is used to draw radicals with indices, e.g. a cube root.

The `<msqrt>` and `<mroot>` elements accept the attributes described in .

The following example contains a square root written with <msqrt> and a cube root written with <mroot>. Note that <msqrt> has several children and the square root applies to all of them. <mroot> has exactly two children: it is a root of index the second child (the number 3), applied to the the first child (the square root). Also note these elements only change the font-size within the <mroot> index, but it is scaled down more than within the numerator and denumerator of the fraction.

The `<msqrt>` and `<mroot>` elements sets math-shift to `compact`. The `<mroot>` element sets increments `scriptlevel` by 2, and sets `displaystyle` to "false" in all but its first child. The user agent stylesheet must contain the following rule in order to implement that behavior:

If the `<msqrt>` or `<mroot>` element do not have their computed `display` property equal to `math` or `inline-math` then they are laid out according to the CSS specification where the corresponding value is described. Otherwise, the layout below is performed.

If the `<mroot>` has less or more than two in-flow children, its layout algorithm is the same as the `<mrow>` element. Otherwise, the first in-flow child is called mroot base and the second in-flow child is called mroot index and its layout algorithm is explained below.

In practice, an `<mroot>` element has two children that are in-flow. Hence the CSS rules basically performs `scriptlevel` and `displaystyle` changes for the index.

The children of the `<msqrt>` element are laid out using the algorithm of the `<mrow>` element to produce a box that is also called the msqrt base. In particular, the algorithm for stretching operators along the block axis is used.

The radical symbol must only be painted if the `visibility` of the `<msqrt>` or `<mroot>` element is `visible`. In that case, the radical symbol must be painted with the `color` of that element.

The radical glyph is the glyph obtained for the character U+221A SQUARE ROOT.

The radical gap is given by RadicalVerticalGap if the math-style is `compact` and RadicalDisplayStyleVerticalGap if the math-style is `normal`.

The radical target size for the stretchy radical glyph is the sum of RadicalRuleThickness, radical gap and the ink height of the base.

The box metrics of the radical glyph and painting of the surd are given by the algorithm to shape a stretchy glyph to block dimension the target size for the radical glyph.

##### Square root

The `<msqrt>` element is laid out as shown on .

The min-content inline size (respectively max-content inline size) of the content is the sum of the preferred inline size of a glyph stretched along the block axis for the radical glyph and of the min-content inline size (respectively max-content inline size) of the base's margin box.

The inline size of the content is the sum of the advance width of the box metrics of the radical glyph and of the inline size of the base's margin's box.

The line-ascent of the content is the maximum between:

The line-descent of the content is the maximum between:

The inline size of the overbar is the inline size of the base's margin's box. The inline offsets of the base and overbar are also the same and equal to the width of the box metrics of the radical glyph.

The alphabetic baseline of the base is aligned with the alphabetic baseline. The block size of the overbar is RadicalRuleThickness. Its vertical center is shifted away from the alphabetic baseline by a distance towards the line-over equal to the line-ascent of the content, minus the RadicalExtraAscender, minus half the RadicalRuleThickness.

Finally, the painting of the surd is performed:

##### Root with index

The `<mroot>` element is laid out as shown on . The root index is first ignored and the base and radical glyph are laid out as shown on figure using the same algorithm as in in order to produce a margin box B (represented in green).

The min-content inline size (respectively max-content inline size) of the content is the sum of max(0, RadicalKernBeforeDegree), the index's min-content inline size (respectively max-content inline size) of the index's margin box, max(−min-content inline size, RadicalKernAfterDegree) (respectively max(−max-content inline size, RadicalKernAfterDegree)) and of the min-content inline size (respectively max-content inline size) of B.

The inline size of the content is the sum of AdjustedRadicalKernBeforeDegree, the inline size of the index's margin box, AdjustedRadicalKernAfterDegree and of the inline size of B.

The line-ascent of the content is the maximum between:

The line-descent of the content is the maximum between:

The inline offset of the index is AdjustedRadicalKernBeforeDegree. The inline-offset of the base is the same + the inline size of the index's margin box.

The alphabetic baseline of B is aligned with the alphabetic baseline. The alphabetic baseline of the index is shifted away from the line-under edge by a distance of RadicalDegreeBottomRaisePercent × the block size of B + the line-descent of the index's margin box.

In general, the kerning before the root index is positive while the kerning after it is negative, which means that the root element will have some inline-start space and that the root index will overlap the surd.

#### Style Change `<mstyle>`

Historically, the `<mstyle>` element was introduced to make style changes that affect the rendering of its contents.

The `<mstyle>` element accepts the attributes described in . Its layout algorithm is the same as the `<mrow>` element.

`<mstyle>` is implemented for compatibility with full MathML. Authors whose only target is MathML Core are encouraged to use CSS for styling.

In the following example, <mstyle> is used to set the scriptlevel and displaystyle. Observe this is respectively affecting the font-size and placement of subscripts of their descendants. In MathML Core, one could just have used <mrow> elements instead.

#### Error Message `<merror>`

The `<merror>` element displays its contents as an ”error message”. The intent of this element is to provide a standard way for programs that generate MathML from other input to report syntax errors in their input.

In the following example, <merror> is used to indicate a parsing error for some LaTeX-like input:

The `<merror>` element accepts the attributes described in . Its layout algorithm is the same as the `<mrow>` element. The user agent stylesheet must contain the following rule in order to visually highlight the error message:

#### Adjust Space Around Content `<mpadded>`

The `<mpadded>` element renders the same as its in-flow child content, but with the size and relative positioning point of its content modified according to `<mpadded>`’s attributes.

The `<mpadded>` element accepts the attributes described in as well as the following attributes:

The `mpadded@width`, `mpadded@height`, `mpadded@depth`, `mpadded@lspace` and `mpadded@voffset` if present, must have a value that is a valid length-percentage.

In the following example, <mpadded> is used to tweak spacing around a fraction (a blue background is used to visualize it). Without attributes, it behaves like an <mrow> but the attributes allow to specify the size of the box (width, height, depth) and position of the fraction within that box (lspace and voffset).

##### Inner box and requested parameters

In-flow children of the `<mpadded>` element are laid out using the algorithm of the `<mrow>` element to produce the mpadded inner box for the content with parameters called inner inline size, inner line-ascent and inner line-descent. The requested `<mpadded>` parameters are determined as follows:

• If the `width` (respectively `height`, `depth`, `lspace`, `voffset`) attributes are absent or invalid the requested width (respectively height, depth, lspace, voffset) is the inner inline size (respectively inner line-ascent, inner line-descent, `0`, `0`).
• If the `width` (respectively `height`, `depth`, `lspace`, `voffset`) attribute is a `length-percentage` then the requested width (respectively height, depth, lspace, voffset) is the resolved value with percentage interpreted relative to the inner inline size (respectively inner line-ascent, inner line-descent, `0`, `0`).

If one of the requested width, depth, height or lspace values calculated above is negative then it is treated as `0`.

##### Layout of `<mpadded>`

If the `<mpadded>` element does not have its computed `display` property equal to `math` or `inline-math` then it is laid out according to the CSS specification where the corresponding value is described. Otherwise, it is laid out as shown on .

The min-content inline size (respectively max-content inline size) of the content is the requested width calculated in but using the min-content inline size (respectively max-content inline size) of the mpadded inner box instead of the "inner inline size".

The inline size of the content is the requested width calculated in .

The line-ascent of the content is the requested height. The line-descent of the content is the requested depth.

The mpadded inner box is placed so that its alphabetic baseline is shifted away from the alphabetic baseline by the requested voffset towards the line-over.

#### Making Sub-Expressions Invisible `<mphantom>`

Historically, the `<mphantom>` element was introduced to render its content invisibly, but with the same metrics size and other dimensions, including alphabetic baseline positionthat its contents would have if they were rendered normally.

In the following example, <mphantom> is used to ensure alignment of corresponding parts of the numerator and denominator of a fraction:

The `<mphantom>` element accepts the attributes described in . Its layout algorithm is the same as the `<mrow>` element. The user agent stylesheet must contain the following rule in order to hide the content:

`<mphantom>` is implemented for compatibility with full MathML. Authors whose only target is MathML Core are encouraged to use CSS for styling.

### Script and Limit Schemata

The elements described in this section position one or more scripts around a base. Attaching various kinds of scripts and embellishments to symbols is a very common notational device in mathematics. For purely visual layout, a single general-purpose element could suffice for positioning scripts and embellishments in any of the traditional script locations around a given base. However, in order to capture the abstract structure of common notation better, MathML provides several more specialized scripting elements.

In addition to sub/superscript elements, MathML has overscript and underscript elements that place scripts above and below the base. These elements can be used to place limits on large operators, or for placing accents and lines above or below the base.

#### Subscripts and Superscripts `<msub>`, `<msup>`, `<msubsup>`

The `<msub>`, `<msup>` and `<msubsup>` elements are used to attach subscript and superscript to a MathML expression. They accept the attributes described in .

The following example, shows basic use of subscripts and superscripts. The font-size is automatically scaled down within the scripts.

If the `<msub>`, `<msup>` or `<msubsup>` elements do not have their computed `display` property equal to `math` or `inline-math` then they are laid out according to the CSS specification where the corresponding value is described. Otherwise, the layout below is performed.

##### Children of `<msub>`, `<msup>`, `<msubsup>`

If the `<msub>` element has less or more than two in-flow children, its layout algorithm is the same as the `<mrow>` element. Otherwise, the first in-flow child is called the msub base, the second in-flow child is called the msub subscript and the layout algorithm is explained in .

If the `<msup>` element has less or more than two in-flow children, its layout algorithm is the same as the `<mrow>` element. Otherwise, the first in-flow child is called the msup base, the second in-flow child is called the msup superscript and the layout algorithm is explained in .

If the `<msubsup>` element has less or more than three in-flow children, its layout algorithm is the same as the `<mrow>` element. Otherwise, the first in-flow child is called the msubsup base, the second in-flow child is called the msubsup subscript, its third in-flow child is called the msupsup superscript and the layout algorithm is explained in .

##### Base with subscript

The `<msub>` element is laid out as shown on . `LargeOpItalicCorrection` is the italic correction of the base if it is an embellished operator with the `largeop` property and 0 otherwise.

The min-content inline size (respectively max-content inline size) of the content is the min-content inline size (respectively max-content inline size) inline size of the base's margin box`LargeOpItalicCorrection` + min-content inline size (respectively max-content inline size) of the subscript's margin box + SpaceAfterScript.

If there is an inline stretch size constraint or a block stretch size constraint then the base is also laid out with the same stretch size contraint and otherwise it is laid out without any stretch size constraint. The scripts are always laid out without any stretch size constraint.

The inline size of the content is the inline size of the base's margin box`LargeOpItalicCorrection` + the inline size of the subscript's margin box + SpaceAfterScript.

`SubShift` is the maximum between:

The line-ascent of the content is the maximum between:

The line-descent of the content is the maximum between:

The inline offset of the base is 0 and the inline offset of the subscript is the inline size of the base's margin box`LargeOpItalicCorrection`.

The base is placed so that its alphabetic baseline matches the alphabetic baseline. The subscript is placed so that its alphabetic baseline is shifted away from the alphabetic baseline by `SubShift` towards the line-under.

##### Base with superscript

The `<msup>` element is laid out as shown on . `ItalicCorrection` is the italic correction of the base if it is not an embellished operator with the `largeop` property and 0 otherwise.

The min-content inline size (respectively max-content inline size) of the content is the min-content inline size (respectively max-content inline size) of the base's margin box + `ItalicCorrection` + the min-content inline size (respectively max-content inline size) of the superscript's margin box + SpaceAfterScript.

If there is an inline stretch size constraint or a block stretch size constraint then the base is also laid out with the same stretch size contraint and otherwise it is laid out without any stretch size constraint. The scripts are always laid out without any stretch size constraint.

The inline size of the content is the inline size of the base's margin box + `ItalicCorrection` + the inline size of the superscript's margin box + SpaceAfterScript.

`SuperShift` is the maximum between:

The line-ascent of the content is the maximum between:

The line-descent of the content is the maximum between:

The inline offset of the base is 0 and the inline offset of superscript is the inline size of the base's margin box + `ItalicCorrection`.

The base is placed so that its alphabetic baseline matches the alphabetic baseline. The superscript is placed so that its alphabetic baseline is shifted away from the alphabetic baseline by `SuperShift` towards the line-over.

##### Base with subscript and superscript

The `<msubsup>` element is laid out as shown on . `LargeOpItalicCorrection` and `SubShift` are set as in . `ItalicCorrection` and `SuperShift` are set as in .

The min-content inline size (respectively max-content inline size and inline size) of the content is the maximum between the min-content inline size (respectively max-content inline size and inline size) of the content calculated in and .

If there is an inline stretch size constraint or a block stretch size constraint then the base is also laid out with the same stretch size contraint and otherwise it is laid out without any stretch size constraint. The scripts are always laid out without any stretch size constraint.

If there is an inline stretch size constraint or a block stretch size constraint then the base is also laid out with the same stretch size contraint and otherwise it is laid out without any stretch size constraint. The scripts are always laid out without any stretch size constraint.

`SubSuperGap` is the gap between the two scripts along the block axis and is defined by (`SubShift` − the ink line-ascent of the subscript's margin box) + (`SuperShift` − the ink line-descent of the superscript's margin box). If `SubSuperGap` is not at least SubSuperscriptGapMin then the following steps are performed to ensure that the condition holds:

1. Let Δ be SuperscriptBottomMaxWithSubscript − (`SuperShift` − the ink line-descent of the superscript's margin box). If Δ > 0 then set Δ to the minimum between Δ set SubSuperscriptGapMin`SubSuperGap` and increase `SuperShift` (and so `SubSuperGap` too) by Δ.
2. Let Δ be SubSuperscriptGapMin`SubSuperGap`. If Δ > 0 then increase `SubscriptShift` (and so `SubSuperGap` too) by Δ.

The ink line-ascent (respectively line-ascent, ink line-descent, line-descent) of the content is set to the maximum of the ink line-ascent (respectively line-ascent, ink line-descent, line-descent) of the content calculated in in and but using the adjusted values `SubShift` and `SuperShift` above.

The inline offset and block offset of the base and scripts are performed the same as described in and .

Even when the subscript (respectively superscript) is an empty box, `<subsup>` does not generally render the same as (respectively ) because of the additional constraint on `SubSuperGap`. Moreover, positioning the empty subscript (respectively superscript) may also change the total size.

In order to keep the algorithm simple, no attempt is made to handle empty scripts in a special way.

#### Underscripts and Overscripts `<munder>`, `<mover>`, `<munderover>`

The `<munder>`, `<mover>` and `<munderover>` elements are used to attach accents or limits placed under or over a MathML expression.

The `<munderover>` element accepts the attribute described in as well as the following attributes:

Similarly, the `<mover>` element (respectively `<munder>` element) accepts the attribute described in as well as the `accent` attribute (respectively the `accentunder` attribute).

`accent`, `accentunder`, attributes, if present, must have values that are booleans. User agents must implement them as described in .

The following example, shows basic use of under and over scripts. The font-size is automatically scaled down within the scripts, unless they are meant to be accents.

If the `<munder>`, `<mover>` or `<munderover>` elements do not have their computed `display` property equal to `math` or `inline-math` then they are laid out according to the CSS specification where the corresponding value is described. Otherwise, the layout below is performed.

##### Children of `<munder>`, `<mover>`, `<munderover>`

If the `<munder>` element has less or more than two in-flow children, its layout algorithm is the same as the `<mrow>` element. Otherwise, the first in-flow child is called the munder base and the second in-flow child is called the munder underscript.

If the `<mover>` element has less or more than two in-flow children, its layout algorithm is the same as the `<mrow>` element. Otherwise, the first in-flow child is called the mover base and the second in-flow child is called the mover overscript.

If the `<munderover>` element has less or more than three in-flow children, its layout algorithm is the same as the `<mrow>` element. Otherwise, the first in-flow child is called the munderover base, the second in-flow child is called the munderover underscript and its third in-flow child is called the munderover overscript.

If the `<munder>`, `<mover>` or `<munderover>` element have a computed math-style property equal to `compact` and their base is an embellished operator with the `movablelimits` property, then their layout algorithms are respectively the same as the ones described for `<msub>`, `<msup>` and `<msubsup>` in , and .

Otherwise, the `<mover>`, `<mover>` and `<munderover>` layout algorithms are respectively described in , and

#### Algorithm for stretching operators along the inline axis

The algorithm for stretching operators along the inline axis is as follows.

1. If there is an inline stretch size constraint or block stretch size constraint then the element being laid out is an embellished operator. Layout the base with the same stretch size constraint.
2. Split the list of in-flow children that have not been laid out yet into a first list `LToStretch` containing embellished operators with a stretchy property and inline stretch axis ; and a second list `LNotToStretch`.
3. Perform layout without any stretch size constraint on all the items of `LNotToStretch`. If `LToStretch` is empty then stop. If `LNotToStretch` is empty, perform layout with stretch size constraint 0 on all the items of `LToStretch`.
4. Calculate the target size `T` to the maximum inline size of the margin boxes of child boxes that have been laid out in the previous step.
5. Layout or relayout all the elements of `LToStretch` with inline stretch size constraint `T`.

#### Base with underscript

The `<munder>` element is laid out as shown on . `LargeOpItalicCorrection` is the italic correction of the base if it is an embellished operator with the `largeop` property and 0 otherwise.

The min-content inline size (respectively max-content inline size) of the content are calculated like the inline size of the content below but replacing the inline sizes of the base's margin box and underscript's margin box with the min-content inline size (respectively max-content inline size) of the base's margin box and underscript's margin box.

The in-flow children are laid out using the algorithm for stretching operators along the inline axis.

The inline size of the content is calculated by determining the absolute difference between:

If m is the minimum calculated in the second item above then the inline offset of the base is −m − half the inline size of the base's margin box. The inline offset of the underscript is −m − half the inline size of the underscript's margin box − half `LargeOpItalicCorrection`.

Parameters `UnderShift` and `UnderExtraDescender` are determined by considering three cases in the following order:

1. The base is an embellished operator with the `largeop` property. `UnderShift` is the maximum of

`UnderExtraDescender` is 0.

2. The base is an embellished operator with the `stretchy` property and stretch axis inline. `UnderShift` is the maximum of:

`UnderExtraDescender` is 0.
3. Otherwise, `UnderShift` is equal to UnderbarVerticalGap if the accentunder attribute is equal to `false` and to zero otherwise. `UnderExtraAscender` is UnderbarExtraDescender.

The line-ascent of the content is the maximum between:

The line-descent of the content is the maximum between:

The alphabetic baseline of the base is aligned with the alphabetic baseline. The alphabetic baseline of the underscript is shifted away from the alphabetic baseline and towards the line-under by a distance equal to the ink line-descent of the base's margin box + `UnderShift`.

#### Base with overscript

The `<mover>` element is laid out as shown on . `LargeOpItalicCorrection` is the italic correction of the base if it is an embellished operator with the `largeop` property and 0 otherwise.

The min-content inline size (respectively max-content inline size) of the content are calculated like the inline size of the content below but replacing the inline sizes of the base's margin box and underscript's margin box with the min-content inline size (respectively max-content inline size) of the base's margin box and underscript's margin box.

The in-flow children are laid out using the algorithm for stretching operators along the inline axis.

The `TopAccentAttachment` is the top accent attachment of the overscript or half the inline size of the overscript's margin box if it is undefined.

The inline size of the content is calculated by applying the algorithm for stretching operators along the inline axis for layout and determining the absolute difference between:

• The maximum of:
• The minimum of:
• −Half the inline size of the base's margin box.
• `TopAccentAttachment` + half `LargeOpItalicCorrection`.

If m is the minimum calculated in the second item above then the inline offset of the base is −m − half the inline size of the base's margin. The inline offset of the overscript is −m − half the inline size of the overscript's margin box + half `LargeOpItalicCorrection`.

Parameters `OverShift` and `OverExtraDescender` are determined by considering three cases in the following order:

1. The base is an embellished operator with the `largeop` property. `OverShift` is the maximum of

`OverExtraAscender` is 0.

2. The base is an embellished operator with the `stretchy` property and stretch axis inline. `OverShift` is the maximum of:

`OverExtraDescender` is 0.
3. Otherwise, `OverShift` is equal to

1. OverbarVerticalGap if the accent attribute is equal to `false`.
2. Or AccentBaseHeight minus the line-ascent of the base's margin box if this difference is nonnegative.
3. Or 0 otherwise.

`OverExtraAscender` is OverbarExtraAscender.

For accent overscripts and bases with line-ascents that are at most AccentBaseHeight, the rule from [[OPEN-FONT-FORMAT]] [[?TEXBOOK]] is actually to align the alphabetic baselines of the overscripts and of the bases. This assumes that accent glyphs are designed in such a way that their ink bottoms are more or less AccentBaseHeight above their alphabetic baselines. Hence, the previous rule will guarantee that all the overscript bottoms are aligned while still avoiding collision with the bases. However, MathML can have arbitrary accent overscripts a more general and simpler rule is provided above: Ensure that the bottom of overscript is at least AccentBaseHeight above the alphabetic baseline of the base.

The line-ascent of the content is the maximum between:

The line-descent of the content is the maximum between:

The alphabetic baseline of the base is aligned with the alphabetic baseline. The alphabetic baseline of the overscript is shifted away from the alphabetic baseline and towards the line-over by a distance equal to the ink line-ascent of the base + `OverShift`.

#### Base with underscript and overscript

The general layout of `<munderover>` is shown on . The `LargeOpItalicCorrection`, `UnderShift`, `UnderExtraDescender`, `OverShift`, `OverExtraDescender` parameters are calculated the same as in and .

The min-content inline size, max-content inline size and inline size of the content are calculated as an absolute difference between a maximum inline offset and minimum inline offset. These extrema are calculated by taking the extremum value of the corresponding extrema calculated in and . The inline offsets of the base, underscript and overscript are calculated as in these sections but using the new minimum m (minimum of the corresponding minima).

Like in these sections, the in-flow children are laid out using the algorithm for stretching operators along the inline axis.

The line-ascent and line-descent of the content are also calculated by taking the extremum value of the extrema calculated in and .

Finally, the alphabetic baselines of the base, undescript and overscript are calculated as in sections and .

When the underscript (respectively overscript) is an empty box, the base and overscript (respectively underscript) are laid out similarly to (respectively ) but the position of the empty underscript (respectively overscript) may add extra space. In order to keep the algorithm simple, no attempt is made to handle empty scripts in a special way.

#### Prescripts and Tensor Indices `<mmultiscripts>`

Presubscripts and tensor notations are represented the `<mmultiscripts>` with hints given by the `<mprescripts>` (to distinguish postscripts and prescripts) and `<none>` elements (to indicate empty scripts). These element accept the attributes described in .

The following example, shows basic use of prescripts and postscripts, involving <none> and <mprescripts>. The font-size is automatically scaled down within the scripts.

If the `<mmultiscripts>`, `<mprescripts>` or `<none>` elements do not have their computed `display` property equal to `math` or `inline-math` then they are laid out according to the CSS specification where the corresponding value is described. Otherwise, the layout below is performed.

The empty `<mprescripts>` and `<none>` elements are laid out as an `<mrow>` element.

A valid `<mmultiscripts>` element contains the following in-flow children:

If an `<mmultiscripts>` element is not valid then it is laid out the same as the `<mrow>` element. Otherwise the layout algorithm is explained below.

The `<none>` element is preserved for backward compatibility reasons but is actually not taken into account in the layout algorithm.
##### Base with prescripts and postscripts

The `<mmultiscripts>` element is laid out as shown on . For each postscript pair, the `ItalicCorrection` `LargeOpItalicCorrection` are defined as in and .

The min-content inline size (respectively max-content inline size) of the content is calculated the same as the inline size of the content below, but replacing "inline size" with "min-content inline size" (respectively "max-content inline size") for the base's margin box and scripts's margin boxes.

If there is an inline stretch size constraint or a block stretch size constraint the base is also laid out with the same stretch size constraint. Otherwise it is laid out without any stretch size constraint. The other elements are always laid out without any stretch size constraint.

The inline size of the content is calculated with the following algorithm:

1. Set `inline-offset` to 0.
2. For each prescript pair, increment `inline-offset` by SpaceAfterScript + the maximum of

3. Increment `inline-offset` by the inline size of the base's margin box and set `inline-size` to `inline-offset`.
4. For each postscript pair, modify `inline-size` to be at least:

Increment `inline-offset` to the maximum of:

Increment `inline-offset` by SpaceAfterScript.

5. Return `inline-size`

`SubShift` (respectively `SuperShift`) is calculated by taking the maximum of all subshifts (respectively supershifts) of each subscript/superscript pair as described in .

The line-ascent of the content is calculated by taking the maximum of all the line-ascent of each subscript/superscript pair as described in but using the `SubShift` and `SuperShift` values calculated above.

The line-descent of the content is calculated by taking the maximum of all the line-descent of each subscript/superscript pair as described in but using the `SubShift` and `SuperShift` values calculated above.

Finally, the placement of the in-flow children is performed using the following algorithm:

1. Set `inline-offset` to 0.
2. For each prescript pair:

1. Increment `inline-offset` by SpaceAfterScript.
2. Set `pair-inline-size` to the maximum of
3. Place the subscript at inline-start position `inline-offset` + `pair-inline-size` − the inline size of the subscript's margin box.
4. Place the superscript at inline-start position `inline-offset` + `pair-inline-size` − the inline size of the superscript's margin box.
5. Place the subscript (respectively superscript) so its alphabetic baseline is shifted away from the alphabetic baseline by `SubShift` (respectively `SuperShift`) towards the line-under (respectively line-over).
6. Increment `inline-offset` by `pair-inline-size`.
3. Place the base and `<mprescript>` boxes at inline offsets `inline-offset` and with their alphabetic baselines aligned with the alphabetic baseline.
4. For each postscript pair:

1. Set `pair-inline-size` to the maximum of
2. Place the subscript at inline-start position `inline-offset``LargeOpItalicCorrection`.
3. Place the superscript at inline-start position `inline-offset` + `ItalicCorrection`.
4. Place the subscript (superscript) so its alphabetic baseline is shifted away from the alphabetic baseline by `SubShift` (respectively `SuperShift`) towards the line-under (respectively line-over).
5. Increment `inline-offset` by `pair-inline-size`
6. Increment `inline-offset` by SpaceAfterScript.

An `<mmultiscripts>` with only one postscript pair is laid out the same as a `<msubsup>` with the same in-flow children. However, as noticed for `<msubsup>`, if additionally the subscript (respectively superscript) is an empty box then it is not necessarily laid out the same as an `<msub>` (respectively `<msup>`) element. In order to keep the algorithm simple, no attempt is made to handle empty or `<none>` scripts in a special way.

#### Displaystyle, scriptlevel and math-shift in scripts

For all scripted elements, the rule of thumb is to set `displaystyle` to `false` and to increment `scriptlevel` in all child elements but the first one. However, an `<mover>` (respectively `<munderover>`) element with an `accent` attribute that is an ASCII case-insensitive match to `"true"` does not increment scriptlevel within its second child (respectively third child). Similarly, `<mover>` and `<munderover>` elements with an `accentunder` attribute that is an ASCII case-insensitive match to `"true"` do not increment scriptlevel within their second child.

`<mmultiscripts>` sets `math-shift` to `compact` on its children at even position if they are before an <mprescripts>, and on those at odd position if they are after an <mprescripts>. The `<msub<` and `<msubsup<` elements set `math-shift` to `compact` on their second child. An `<mover>` and `<munderover>` elements with an `accent` attribute that is an ASCII case-insensitive match to `"true"` also sets `math-shift` to `compact` within their first child.

The must contain the following style in order to implement this behavior:

In practice, all the children of the MathML elements described in this section are in-flow and the `<mprescript>` is empty. Hence the CSS rules essentially performs automatic `displaystyle` and `scriptlevel` changes for the scripts ; and `math-shift` changes for subscripts and sometimes the base.

### Tabular Math

Matrices, arrays and other table-like mathematical notation are marked up using `<mtable>` `<mtr>` `<mtd>` elements. These elements are similar to the `<table>`, `<tr>` and `<td>` elements of [[HTML]].

The following example, how tabular layout allows to write a matrix. Note that it is vertically centered with the fraction bar and the middle of the equal sign.

#### Table or Matrix `<mtable>`

The `<mtable>` is laid out as an `inline-table` and sets `displaystyle` to `false`. The user agent stylesheet must contain the following rules in order to implement these properties:

The `mtable` element is as a CSS table and the min-content inline size, max-content inline size, inline size, block size, first baseline set and last baseline set sets are determined accordingly. The center of the table is aligned with the math axis.

#### Row in Table or Matrix `<mtr>`

The `<mtr>` is laid out as `table-row`. The user agent stylesheet must contain the following rules in order to implement that behavior:

The `<mtr>` accepts the attributes described in .

#### Entry in Table or Matrix `<mtd>`

The `<mtd>` is laid out as a `table-cell` with content centered in the cell and a default padding. The user agent stylesheet must contain the following rules:

The `<mtd>` accepts the attributes described in as well as the following attributes:

The `columnspan` (respectively `rowspan`) attribute has the same syntax and semantic as the `<colspan>` (respectively `<rowspan>`) attribute on the `<td>` element from [[HTML]].

The name for the column spanning attribute is `columnspan` as in [[MathML3]] and not `colspan` as in [[HTML]].

### Enlivening Expressions

Historically, the `<maction>` element provides a mechanism for binding actions to expressions.

The `<maction>` element accepts the attributes described in as well as the following attributes:

This specification does not define any observable behavior that is specific to the actiontype and selection attributes.

The following example, shows the "toggle" action type from [[MathML3]] where the renderer alternately displays the selected subexpression, starting from "one third" and cycling through them when there is a click on the selected subexpression ("one quarter", "one half", "one third", etc). This is not part of MathML Core but can be implemented using JavaScript and CSS polyfills. The default behavior is just to render the first child.

The layout algorithm of the `<maction>` element the same as the `<mrow>` element. The user agent stylesheet must contain the following rules in order to hide all but its first child element, which is the default behavior for the legacy actiontype values:

`<maction>` is implemented for compatibility with full MathML. Authors whose only target is MathML Core are encouraged to use other HTML, CSS and JavaScript mechanisms to implement custom actions. They may rely on maction attributes defined in [[MathML3]].

### Semantics and Presentation

The `<semantics>` element is the container element that associates annotations with a MathML expression. Typically, the `<semantics>` element has as its first child element a MathML expression to be annotated while subsequent child elements represent text annotations within an `<annotation>` element, or more complex markup annotations within an `<annotation-xml>` element.

The following example, shows how the fraction "one half" can be annotated with a textual annotation (LaTeX) or an XML annotation (content MathML). These annotations are not intended to be rendered by the user agent.

The `<semantics>` element accepts the attributes described in . Its layout algorithm is the same as the `<mrow>` element. The user agent stylesheet must contain the following rule in order to only render the annotated MathML expression:

The `<annotation-xml>` and `<annotation>` element accepts the attributes described in as well as the following attribute:

This specification does not define any observable behavior that is specific to the encoding attribute.

The layout algorithm of the `<annotation-xml>` and `<annotation>` element is the same as the `<mtext>` element.

Authors can use the encoding attribute to distinguish annotations for HTML integration point, clipboard copy, alternative rendering, etc. In particular, CSS can be used to render alternative annotations e.g.
```            /* Hide the annotated child. */
semantics > :first-child { display: none; }
/* Show all text annotations. */
semantics > annotation { display: inline; }
/* Show all HTML annotations. */
semantics > annotation-xml[encoding="text/html" i],
semantics > annotation-xml[encoding="application/xhtml+xml" i] {
display: inline-block;
}
```

## CSS Extensions for Math Layout

### The `display: math` and `display: inline-math` value

The `display` property from is extended with new values value:

`<display-old> | math | inline-math `

For the `[itex]`, `<mtable>`, `<mtr>` and `<mtd>` elements, the `math` value respectively computes to `inline`, `inline-table`, `table-row` and `table-cell`. MathML Core elements with `display: math` or `display: inline-math` control box generation and layout according to their tag name, as described in the relevant sections while Unknown MathML elements with `display: math` or `display: inline-math` behave the same as the `<mrow>` element. For elements that are not MathML elements, the `display: math` value and `display: inline-math` computes to `none`.

The `display: math` and `display: inline-math` values provide a default layout for MathML elements while at the same time allowing to override it with either native display values or custom values. This allows authors or polyfills to define their own custom notations to tweak or extend MathML Core.

In the following example, the default layout of the MathML <mrow> element is overriden to render its content as a grid.

### New `text-transform` values

The `text-transform` property from is extended with new values:

`<text-transform-old> | math-auto | math-bold | math-italic | math-bold-italic | math-double-struck | math-bold-fraktur | math-script | math-bold-script | math-fraktur | math-sans-serif | math-bold-sans-serif | math-sans-serif-italic | math-sans-serif-bold-italic | math-monospace | math-initial | math-tailed | math-looped | math-stretched`

On text nodes containing a unique character, `math-auto` has the same effect as `math-italic`, otherwise it has no effects.

For the `math-bold`, `math-italic`, `math-bold-italic`, `math-double-struck`, `math-bold-fraktur`, `math-script`, `math-bold-script`, `math-fraktur`, `math-sans-serif`, `math-bold-sans-serif`, `math-sans-serif-italic`, `math-sans-serif-bold-italic`, `math-monospace`, `math-initial`, `math-tailed`, `math-looped` and `math-stretched` values, the transformed text is obtained by performing conversion of each character according to the corresponding bold, italic, bold-italic, double-struck, bold-fraktur, script, bold-script, fraktur, sans-serif, bold-sans-serif, sans-serif-italic, sans-serif-bold-italic, monospace, initial, tailed, looped, stretched tables.

User agents may decide to rely on italic, bold and bold-italic font-level properties when available fonts lack the proper glyphs to perform `math-auto`, `math-italic`, `math-bold`, `math-bold-italic` character-level transforms.

The following example shows a mathematical formula where "exp" is rendered with normal variant, "A" with bold variant, "gl" with fraktur variant, "n" using italic variant and and "R" using double-struck variant.

Values other than `math-auto` are intended to infer specific context-dependent mathematical meaning. In the previous example, one can guess that the author decided to use the convention of bold variables for matrices, fraktur variables for Lie algebras and double-struck variables for set of numbers. Although the corresponding Unicode characters could have been used directly in these cases, it may be helpful for authoring tools or polyfills to support these transformations via the `text-transform` property.

A common style convention is to render identifiers with multiple letters (e.g. the function name "exp") with normal style and identifiers with a single letter (e.g. the variable "n") with italic style. The `math-auto` property is intended to implement this default behavior, which can be overriden by authors if necessary. Note that mathematical fonts are designed with special kind of italic glyphs located at the Unicode positions of , which differ from the shaping obtained via italic font style. Compare this mathematical formula rendered with the Latin Modern Math font using `font-style: italic` (left) and `text-transform: math-auto` (right):

### The `math-style` property

Name: `math-style` `normal | compact` `normal` All elements yes n/a visual specified keyword n/a not animatable

When `math-style` is `compact`, the math layout on descendants try to minimize the logical height by applying the following rules:

• The `font-size` is scaled down when `scriptlevel(auto)` is specified (default for <mfrac>) as described in .
• Operators with the largeop property do not follow rules from to make them bigger.
• Under/over scripts attached to an operator with the movablelimits property are actually drawn as sub/super scripts as described in .
• Smaller vertical gaps and shifts from the OpenType MATH table are used for fractions and radicals, as described in , and .

The following example shows a mathematical formula renderered with its `[itex]` root styled with `math-style: compact` (left) and `math-style: normal` (right). In the former case, the font-size is automatically scaled down within the fractions and the summation limits are rendered as subscript and superscript of the ∑. In the latter case, the ∑ is drawn bigger than normal text and vertical gaps within fractions (even relative to current font-size) is larger.

These two `math-style` values typically correspond to mathematical expressions in inline and display mode respectively [[TeXBook]]. A mathematical formula in display mode may automatically switch to inline mode within some subformulas (e.g. scripts, matrix elements, numerators and denominators, etc) and it is sometimes desirable to override this default behavior. The math-style property allows to easily implement these features for MathML in the User Agent Stylesheet and with the displaystyle attribute ; and also exposes them to polyfills.

### The `math-shift` property

Name: `math-shift` `normal | compact` `normal` All elements yes n/a visual specified keyword n/a not animatable

If the value of `math-shift` is `compact`, the math layout on descendants will use the superscriptShiftUpCramped parameter to place superscript. If the value of `math-shift` is `normal`, the math will use the superscriptShiftUp parameter instead.

This property is used for positioning superscript during the layout of MathML scripted elements. See § and .

In the following example, the two "x squared" are rendered with compact math-style and the same `font-size`. However, the one within the square root is rendered with compact `math-shift` while the other one is rendered with normal `math-shift`, leading to subtle different shift of the superscript "2".

Per [[TeXBook]], a mathematical formula uses normal style by default but may switch to compact style ("cramped" in TeX's terminology) within some subformulas (e.g. radicals, fraction denominators, etc). The math-shift property allows to easily implement these rules for MathML in the User Agent Stylesheet. Page authors or developers of polyfills may also benefit from having access to this property to tweak or refine the default implementation.

### New value `scriptlevel()` function for font-size

The `font-size` property from is extended with new values:

`<font-size-old> | scriptlevel(auto) | scriptlevel(add(<integer>)) | scriptlevel(<integer>)`

Each element has an internal scriptlevel which is determined as folows:

• The internal scriptlevel is 0 on the root element.
• If the specified value of font-size is `scriptlevel(auto)` and the inherited value of math-style is `compact` then the internal scriptlevel of the element is the one of its parent plus one.
• If the specified value of font-size is of the form `scriptlevel(add(<integer>))` then the internal scriptlevel is the one of its parent plus the specified integer.
• If the specified value of font-size is of the form `scriptlevel(<integer>)` then the internal scriptlevel of the element is the specified integer.
• Otherwise, the internal scriptlevel of the element is the same as the one of its parent.

If the specified value font-size is of the form `scriptlevel(...)` then the computed value of font-size is obtained by multiplying the inherited value of `font-size` by a nonzero scale factor calculated by the following procedure:

1. Let A be the internal scriptlevel of the parent, B the internal scriptlevel of the element, C be 0.71 and S be 1.0
• If A = B then return S.
• If B < A, swap A and B and set `InvertScaleFactor` to true.
• Otherwise B > A and set `InvertScaleFactor` to false.
2. Let E be B - A > 0.
3. If the inherited font has an OpenType MATH table:
4. Multiply S by CE
5. Return S if `InvertScaleFactor` is false and 1/S otherwise.

The following example shows a mathematical formula with normal math-style rendered with the Latin Modern Math font. When entering subexpressions like scripts or fractions, the font-size is automatically scaled down according to the values of MATH table contained in that font. Note that font-size is scaled down when entering the superscripts but even faster when entering a root's prescript. Also it is scaled down when entering the inner fraction but not when entering the outer one, due to automatic change of math-style in fractions.

These rules from [[TeXBook]] are subtle and it's worth having a separate `scriptlevel()` function to express and handle them. They can be implemented in MathML using the User Agent Stylesheet. Page authors or developers of polyfills may also benefit from having access to this property to tweak or refine the default implementation. In particular, the scriptlevel attribute from MathML provides a way to perform scriptlevel changes.

## OpenType `MATH` table

This chapter describes features provided by `MATH` table of an OpenType font [[OPEN-FONT-FORMAT]]. Throughout this chapter, a C-like notation `Table.Subtable1[index].Subtable2.Parameter` is used to denote OpenType parameters. Such parameters may not be available (e.g. if the font lack one of the subtable, has an invalid offset, etc) and so fallback options are provided.

It is strongly encouraged to render MathML with a math font with the proper OpenType features. There is no guarantee that the fallback options provided will provide good enough rendering.

OpenType values expressed in design units (perhaps indirectly via a `MathValueRecord` entry) are scaled to appropriate values for layout purpose, taking into account `head.unitsPerEm`, CSS `font-size` or zoom level.

### Layout constants (`MathConstants`)

These are global layout constants for a given mathematical font:

Default fallback constant
0
Default rule thickness
`post.underlineThickness`
scriptPercentScaleDown
`MATH.MathConstants.scriptPercentScaleDown / 100` or 0.71 if `MATH.MathConstants.scriptPercentScaleDown` is null or not available.
scriptScriptPercentScaleDown
`MATH.MathConstants.scriptScriptPercentScaleDown / 100` or 0.5041 if `MATH.MathConstants.scriptScriptPercentScaleDown` is null or not available.
displayOperatorMinHeight
`MATH.MathConstants.displayOperatorMinHeight` or Default fallback constant if the constant is not available.
axisHeight
`MATH.MathConstants.axisHeight` or Default fallback constant if the constant is not available.
accentBaseHeight
`MATH.MathConstants.accentBaseHeight` or `OS/2.sxHeight` if the constant is not available.
subscriptShiftDown
`MATH.MathConstants.subscriptShiftDown` or `OS/2.ySubscriptYOffset` if the constant is not available.
subscriptTopMax
`MATH.MathConstants.subscriptTopMax` or ⅘ × `OS/2.sxHeight` if the constant is not available.
subscriptBaselineDropMin
`MATH.MathConstants.subscriptBaselineDropMin` or Default fallback constant if the constant is not available.
superscriptShiftUp
`MATH.MathConstants.superscriptShiftUp` or `OS/2.ySuperscriptYOffset` if the constant is not available.
superscriptShiftUpCramped
`MATH.MathConstants.superscriptShiftUpCramped` or Default fallback constant if the constant is not available.
superscriptBottomMin
`MATH.MathConstants.superscriptBottomMin` or ¼ × `OS/2.sxHeight` if the constant is not available.
superscriptBaselineDropMax
`MATH.MathConstants.superscriptBaselineDropMax` or Default fallback constant if the constant is not available.
subSuperscriptGapMin
`MATH.MathConstants.subSuperscriptGapMin` or 4 × default rule thickness if the constant is not available.
superscriptBottomMaxWithSubscript
`MATH.MathConstants.superscriptBottomMaxWithSubscript` or ⅘ × `OS/2.sxHeight` if the constant is not available.
spaceAfterScript
`MATH.MathConstants.spaceAfterScript` or 1/24em if the constant is not available.
upperLimitGapMin
`MATH.MathConstants.upperLimitGapMin` or Default fallback constant if the constant is not available.
upperLimitBaselineRiseMin
`MATH.MathConstants.upperLimitBaselineRiseMin` or Default fallback constant if the constant is not available.
lowerLimitGapMin
`MATH.MathConstants.lowerLimitGapMin` or Default fallback constant if the constant is not available.
lowerLimitBaselineDropMin
`MATH.MathConstants.lowerLimitBaselineDropMin` or Default fallback constant if the constant is not available.
stackTopShiftUp
`MATH.MathConstants.stackTopShiftUp` or Default fallback constant if the constant is not available.
stackTopDisplayStyleShiftUp
`MATH.MathConstants.stackTopDisplayStyleShiftUp` or Default fallback constant if the constant is not available.
stackBottomShiftDown
`MATH.MathConstants.stackBottomShiftDown` or Default fallback constant if the constant is not available.
stackBottomDisplayStyleShiftDown
`MATH.MathConstants.stackBottomDisplayStyleShiftDown` or Default fallback constant if the constant is not available.
stackGapMin
`MATH.MathConstants.stackGapMin` or 3 × default rule thickness if the constant is not available.
stackDisplayStyleGapMin
`MATH.MathConstants.stackDisplayStyleGapMin` or 7 × default rule thickness if the constant is not available.
stretchStackTopShiftUp
`MATH.MathConstants.stretchStackTopShiftUp` or Default fallback constant if the constant is not available.
stretchStackBottomShiftDown
`MATH.MathConstants.stretchStackBottomShiftDown` or Default fallback constant if the constant is not available.
stretchStackGapAboveMin
`MATH.MathConstants.stretchStackGapAboveMin` or upperLimitGapMin if the constant is not available.
stretchStackGapBelowMin
`MATH.MathConstants.stretchStackGapBelowMin` or lowerLimitGapMin if the constant is not available.
fractionNumeratorShiftUp
`MATH.MathConstants.fractionNumeratorShiftUp` or Default fallback constant if the constant is not available.
fractionNumeratorDisplayStyleShiftUp
`MATH.MathConstants.fractionNumeratorDisplayStyleShiftUp` or stackTopDisplayStyleShiftUp if the constant is not available.
fractionDenominatorShiftDown
`MATH.MathConstants.fractionDenominatorShiftDown` or Default fallback constant if the constant is not available.
fractionDenominatorDisplayStyleShiftDown
`MATH.MathConstants.fractionDenominatorDisplayStyleShiftDown` or stackBottomDisplayStyleShiftDown if the constant is not available.
fractionNumeratorGapMin
`MATH.MathConstants.fractionNumeratorGapMin` or default rule thickness if the constant is not available.
fractionNumDisplayStyleGapMin
`MATH.MathConstants.fractionNumDisplayStyleGapMin` or 3 × default rule thickness if the constant is not available.
fractionRuleThickness
`MATH.MathConstants.fractionRuleThickness` or default rule thickness if the constant is not available.
fractionDenominatorGapMin
`MATH.MathConstants.fractionDenominatorGapMin` or default rule thickness if the constant is not available.
fractionDenomDisplayStyleGapMin
`MATH.MathConstants.fractionDenomDisplayStyleGapMin` or 3 × default rule thickness if the constant is not available.
overbarVerticalGap
`MATH.MathConstants.overbarVerticalGap` or 3 × default rule thickness if the constant is not available.
overbarRuleThickness
`MATH.MathConstants.overbarRuleThickness` or default rule thickness if the constant is not available.
overbarExtraAscender
`MATH.MathConstants.overbarExtraAscender` or default rule thickness if the constant is not available.
underbarVerticalGap
`MATH.MathConstants.underbarVerticalGap` or 3 × default rule thickness if the constant is not available.
underbarRuleThickness
`MATH.MathConstants.underbarRuleThickness` or default rule thickness if the constant is not available.
`MATH.MathConstants.underbarExtraDescender` or default rule thickness if the constant is not available.
`MATH.MathConstants.radicalVerticalGap` or 1¼ × default rule thickness if the constant is not available.
`MATH.MathConstants.radicalDisplayStyleVerticalGap` or default rule thickness + ¼ `OS/2.sxHeight` if the constant is not available.
`MATH.MathConstants.radicalRuleThickness` or default rule thickness if the constant is not available.
`MATH.MathConstants.radicalExtraAscender` or radicalRuleThickness if the constant is not available.
`MATH.MathConstants.radicalKernBeforeDegree` or 5/18em if the constant is not available.
`MATH.MathConstants.radicalKernAfterDegree` or −10/18em if the constant is not available.
`MATH.MathConstants.radicalDegreeBottomRaisePercent / 100.0` or 0.6 if the constant is not available.

### Glyph information (`MathGlyphInfo`)

MathTopAccentAttachment is at risk.

These are per-glyph tables for a given mathematical font:

MathItalicsCorrectionInfo
The subtable `MATH.MathGlyphInfo.MathItalicsCorrectionInfo` of italics correction values. Use the corresponding value in `MATH.MathGlyphInfo.MathItalicsCorrectionInfo.italicsCorrection` if there is one for the requested glyph or or `0` otherwise.
MathTopAccentAttachment
The subtable `MATH.MathGlyphInfo.MathTopAccentAttachment` of positioning top math accents along the inline axis. Use the corresponding value in `MATH.MathGlyphInfo.MathTopAccentAttachment.topAccentAttachment` if there is one for the requested glyph or or half the advance width of the glyph otherwise.

### Size variants for operators (`MathVariants`)

This section describes how to handle stretchy glyphs of arbitrary size using the `MATH.MathVariants` table.

#### The `GlyphAssembly` table

This section is based on [[?OPEN-TYPE-MATH-IN-HARFBUZZ]]. For convenience, the following definitions are used:

• omin is `MATH.MathVariant.minConnectorOverlap`.
• A `GlyphPartRecord` is an extender if and only if `GlyphPartRecord.partFlags` has the `fExtender` flag set.
• A `GlyphAssembly` is horizontal if it is obtained from `MathVariant.horizGlyphConstructionOffsets`. Otherwise it is vertical (and obtained from `MathVariant.vertGlyphConstructionOffsets`).
• For a given `GlyphAssembly` table, NExt (respectively NNonExt) is the number of extenders (respectively non-extenders) in `GlyphAssembly.partRecords`.
• For a given `GlyphAssembly` table, SExt (respectively SNonExt) is the sum of `GlyphPartRecord.fullAdvance` for all extenders (respectively non-extenders) in `GlyphAssembly.partRecords`.
• SExt,NonOverlapping = SExtomin NExt is the sum of maximum non overlapping parts of extenders.

User agents must treat the `GlyphAssembly` as invalid if the following conditions are not satisfied:

• NExt > 0. Otherwise, the assembly cannot be grown by repeating extenders.
• SExt,NonOverlapping > 0. Otherwise, the assembly does not grow when joining extenders.
• For each `GlyphPartRecord` in `GlyphAssembly.partRecords`, the values of `GlyphPartRecord.startConnectorLength` and `GlyphPartRecord.endConnectorLength` must be at least omin. Otherwise, it is not possible to satisfy the condition of `MathVariant.minConnectorOverlap`.

In this specification, a glyph assembly is built by repeating each extender r times and using the same overlap value o between each glyph. The number of glyphs in such an assembly is AssemblyGlyphCount(r) = NNonExt + r NExt while the stretch size is AssembySize(o, r) = SNonExt + r SExt − o (AssemblyGlyphCount(r) − 1).

rmin is the minimal number of repetitions needed to obtain an assembly of size at least T i.e. the minimal r such that AssembySize(omin, r)) ≥ T. It is defined as the maximum between 0 and the ceiling of ((T − SNonExt + omin (NNonExt − 1)) / SExt,NonOverlapping).

omax is the maximum overlap possible to build an assembly of size at least T by repeating each extender rmin times. If AssemblyGlyphCount(rmin) ≤ 1, then the actual overlap value is irrelevant. Otherwise, omax is defined to be the minimum of:

• omax,theorical = (AssembySize(0, rmin) − T) / (AssemblyGlyphCount(rmin) − 1) is the theorical overlap obtained by splitting evenly the extra size of an assembly built with null overlap.
• `GlyphPartRecord.startConnectorLength` for all the entries in `GlyphAssembly.partRecords`, excluding the last one if it is not an extender.
• `GlyphPartRecord.endConnectorLength` for all the entries in `GlyphAssembly.partRecords`, excluding the first one if it is not an extender.

The glyph assembly stretch size for a target size T is AssembySize(omax, rmin).

The glyph assembly width, glyph assembly ascent and glyph assembly descent are defined as follows:

• If `GlyphAssembly` is vertical, the width is the maximum advance width of the glyphs of id `GlyphPartRecord.glyphID` for all the `GlyphPartRecord` in `GlyphAssembly.partRecords`, the ascent is the glyph assembly stretch size for a given target size `T` and the descent is 0.
• Otherwise, the `GlyphAssembly` is horizontal, the width is glyph assembly stretch size for a given target size `T` while the ascent (respectively descent) is the the maximum ascent (respectively descent) of the glyphs of id `GlyphPartRecord.glyphID` for all the `GlyphPartRecord` in `GlyphAssembly.partRecords`.

The glyph assembly height is the sum of the glyph assembly ascent and glyph assembly descent.

The horizontal (respectively vertical) metrics for a vertical (respectively horizontal) glyph assembly do not depend on the target size `T`.

The shaping of the glyph assembly is performed with the following algorithm:

1. Calculate rmin and omax.
2. Set `(x, y)` to `(0, 0)`, `RepetitionCounter` to 0 and `PartIndex` to -1.
3. Repeat the following steps:
1. If `RepetitionCounter` is 0, then
1. Increment `PartIndex`.
2. If `PartIndex` is `GlyphAssembly.partCount` then stop.
3. Otherwise, set `Part` to `GlyphAssembly.partRecords[PartIndex]`. Set `RepetitionCounter` to rmin if `Part` is an extender and to 1 otherwise.
• If the glyph assembly is horizontal then draw the glyph of id `Part.glyphID` so that its (left, baseline) coordinates are at position `(x, y)`. Set `x` to ```x + Part.fullAdvance − omax```
• Otherwise (if the glyph assembly is vertical), then draw the glyph of id `Part.glyphID` so that its (left, bottom) coordinates are at position `(x, y)`. Set `y` to ```y − Part.fullAdvance + omax```
2. Decrement `RepetitionCounter`.

#### Algorithms for glyph stretching

The preferred inline size of a glyph stretched along the block axis is calculated using the following algorithm:

1. Set `S` to the glyph's advance width.
2. If there is a `MathGlyphConstruction` table in the `MathVariants.vertGlyphConstructionOffsets` table for the given glyph:
1. For each `MathGlyphVariantRecord` in `MathGlyphConstruction.mathGlyphVariantRecord`, ensure that `S` is at least the advance width of the glyph of id `MathGlyphVariantRecord.variantGlyph`.
2. If there is valid `GlyphAssembly` subtable, then ensure that `S` is at least the glyph assembly width.
3. Return `S`.
The preferred inline size of a glyph stretched along the block axis will return the maximum width of all possible vertical constructions for that glyph. In practice, math fonts are designed so that vertical constructions almost constant width so possible over-estimation of the actual width is small.

The algorithm to shape a stretchy glyph to inline (respectively block) dimension `T` is the following:

1. If there is not any `MathGlyphConstruction` table in the `MathVariants.horizGlyphConstructionOffsets` table (respectively `MathVariants.vertGlyphConstructionOffsets` table) for the given glyph the exit with failure.
2. If the glyph's advance width (respectively height) is at least `T` then use normal shaping and bounding box for that glyph, the MathItalicsCorrectionInfo for that glyph as italic correction and exit with success.
3. Browse the list of `MathGlyphVariantRecord` in `MathGlyphConstruction.mathGlyphVariantRecord`. If one `MathGlyphVariantRecord.advanceMeasurement` is at least `T` then use normal shaping and bounding box for `MathGlyphVariantRecord.variantGlyph`, the MathItalicsCorrectionInfo for that glyph as italic correction and exit with success.
4. If there is valid `GlyphAssembly` subtable then use the bounding box given by glyph assembly width, glyph assembly ascent, the value `GlyphAssembly.italicsCorrection` as italic correction, perform shaping of the glyph assembly and exit with success.
5. If none of the stretch option above allowed to cover the target size `T`, then choose last one that was tried and exit with success.
If a font does not provide tables for stretchy constructions, User Agents may use their own internal constructions as a fallback such that the one suggested in .

## User Agent Stylesheet

```@namespace url(http://www.w3.org/1998/Math/MathML);

/* Default display */

/* The [itex] element */

/* <mrow>-like elements */

/* Token elements */

/* Tables */

/* Fractions */

/* Other rules for scriptlevel, displaystyle and math-shift */

```
Improve rules for href hyperlinks and focusable elements?

## Operator Tables

### Operator Dictionary

The following dictionary for default values of of operators when they are not specified via explicit attributes or equal to the generic default values. Please refer to for explanation about how to use this dictionary and how to determine the values `Content` and `Form` indexing it. Tables below are suitable for computer manipulation, see for an alternative presentation.

This compact form removes about 800 entries from the original operator dictionary that actually correspond to default values. They are not necessary since they are handled by the fallback case of anyway. For other (`Content`, `Form`) key, the search is done as follows:

1. Set properties `stretchy`, `symmetric` `largeop`, `movablelimits` to `false`.
2. If `Content` as an UTF-16 string does not have length or 1 or 2 then exit with `NotFound` status.
3. If `Content` is a single character in the range U+0320–U+03FF then exit with `NotFound` status. Otherwise, if it has two characters:
• If `Content` is the surrogate pairs corresponding to U+1EEF0 ARABIC MATHEMATICAL OPERATOR MEEM WITH HAH WITH TATWEEL or U+1EEF1 ARABIC MATHEMATICAL OPERATOR HAH WITH DAL and `Form` is postfix, then set properties according to category I of and move to the last step.
• If the second character is U+338 COMBINING LONG SOLIDUS OVERLAY or U+20D2 COMBINING LONG VERTICAL LINE OVERLAY then replace `Content` with the first character.
• Otherwise, if `Content` it is listed in `Operators_2_ascii_chars` then replace `Content` with the Unicode character "U+0320 plus the index of `Content` in `Operators_2_ascii_chars`".
• Otherwise exit with `NotFound` status.
4. During this step, the algorithm will try and find a category corresponding to (`Content`, `Form`) from and either exit with `NotFound` status or and move to the next point. More precisely, this can be done as follows:
• For categories that don't have an encoding in (namely K, M) perform a few direct verifications on (`Content`, `Form`) according to . If a result is found then set the properties according to . Otherwise exit with `NotFound` status.
• For other categories, perform the following steps:
• Set `Key` to `Content` if it is in range U+0000–U+03FF ; or to `Content` − 0x1C00 if it is in range U+2000–U+2BFF. Otherwise, exit with `NotFound` status. `Key` is at most 0x0FFF.
• Add 0x0000, 0x1000, 0x2000 to `Key` according to whether `Form` is `infix`, `prefix`, `postfix` respectively. `Key` is at most 0x2FFF.
• Search an `Entry` in table such `Entry` % 0x4000 is equal to `Key`. Either exit with `NotFound` status or set the properties corresponding to the category with encoding `Entry` / 0x1000 in .
5. Return the calculated (`lspace`, `rspace`, `stretchy`, `symmetric` `largeop`, `movablelimits`) value.

When encoded as ranges, one can perform a binary search by looking for the range start, followed by an extra check on the range length. Since log is concave, it is worse to do one binary search on each large subtable of than one binary search on the whole table of . One can see that there are several contiguous Unicode blocks, so encoding tables as ranges allow to get almost 8 bits per entry.

Alternatively, it is possible to use a perfect hash function to implement table lookup in constant time [[?gperf]] [[?CMPH]]. This would instead take 16 bits per entry, plus 16 bits per extra empty entry (for non-minimal perfect hash function) as well as extra data to store the hash function parameters. For minimal perfect hash function, the theorical lower bound for storing these parameters is 1.44bits/entry and existing algorithms range from close to that limit up to 4bits/entry.

### Stretchy Operator Axis

The default stretch axis for all characters is block. However, the stretch axis for the following characters is inline:

The stretch axis can be included as a boolean property of the operator dictionary. But since it does not depend on the form and since very few operators can stretch along the inline axis, it might be better implemented as a separate sorted array.

The following dictionary provides a human-readable version of . Please refer to for explanation about how to use this dictionary and how to determine the values `Content` and `Form` indexing together the dictionary.

The values for rspace and lspace are indicated in the corresponding columns. The values of `stretchy`, `symmetric`, `largeop`, `movablelimits`, are `true` if they are listed in the "properties" column.

### Combining Character Equivalences

The following table gives mappings between spacing and non spacing characters when used in MathML accent constructs.

## Unicode-based Glyph Assemblies

The following table provide fallback that user agents may use for stretching a given base character when the font does not provide a `MATH.MathVariants` table. The algorithms of works the same except with some adjustments:

• Entries are indexed by the base character.
• All the glyph IDs and metrics have to be deduced from unicode code points.
• If the glyph construction is horizontal then the entry corresponds to a `MathVariants.horizGlyphConstructionOffsets[]` item ; if it is vertical it corresponds to a `MathVariants.vertGlyphConstructionOffsets[]` item.
• The `MathGlyphConstruction.mathGlyphVariantRecord` is always empty.
• The `MathVariants.minConnectorOverlap`, `GlyphPartRecord.startConnectorLength` and `GlyphPartRecord.endConnectorLength` are treated as 0.
• The array of `MathGlyphConstruction.GlyphAssembly.partRecords` is built from each table row as follows:
1. A (non-extender) bottom/left character
2. Followed by an extender character.
3. Optionally followed by this:
• Optionally, an (non-extender) middle character and the same extender character previously mentioned.
• A (non-extender) top/right character.

## Acknowledgments

MathML Core is based on MathML3. See the appendix E of [[MathML3]] for the people that contributed to that specification.

We would like to thank the people who, through their input and feedback on public communication channels have helped us with the creation of this specification: André Greiner-Petter, Anne van Kesteren, Boris Zbarsky, Brian Smith, Daniel Marques, David Carlisle, Deyan Ginev, Elika Etemad, Emilio Cobos Álvarez, ExE Boss, Ian Kilpatrick, Koji Ishii, L. David Baron, Michael Kohlhase, Michael Smith, Moritz Schubotz, Murray Sargent, Ryosuke Niwa, Sergey Malkin, Tab Atkins Jr., Viktor Yaffle and frankvel.

In addition, we would like to extend special thanks to Brian Kardell, Neil Soiffer and Rob Buis for help with the editing.

Many thanks also to the following people for their help with the test suite: Brian Kardell, Frédéric Wang, Neil Soiffer and Rob Buis. Several tests are also based on MathML tests from browser repositories and we are grateful to the Mozilla and WebKit contributors.

Community Group members who have regularly participated to MathML Core meetings during the development of this specification: Brian Kardell, Bruce Miller, David Carlisle, Murray Sargent, Frédéric Wang, Neil Soiffer (Chair), Patrick Ion, Rob Buis, David Farmer, Steve Noble, Daniel Marques, Sam Dooley.

## Privacy and Security Considerations

As explained in , MathML can be embedded into an SVG image via the `<foreignObject>` element which can thus be used in a `<canvas>` element. UA may decide to implement any measure to prevent potential information leakage such as tainting the canvas and returning a `"SecurityError"` `DOMException` when one tries to access the canvas' content via JavaScript APIs.

This specification adds an `href` attribute that can be used to make MathML elements match `:link` and `:visited` pseudo-classes and one could rely on these features to determine whether a link has been visited. UAs may implement suggestions from [[SELECT]] to preserve the user's privacy.

This specification only adds script execution mechanisms in the the MathML event handler attributes described in and in `javascript:...` links for the `href` attribute. UAs may decide to apply the same security restrictions as HTML and SVG to prevent execution of scripts in these attributes.

This specification describes layout of a DOM elements which may involve system fonts. Like for HTML/CSS layout, it is thus possible to use JavaScript APIs to measure box sizes and positions and infer data from system fonts (e.g. default fonts, available glyphs, font layout parameters...). The only font informations that are not exposed by other existing Web APIs are the math layout data described in .

In MathML3, it was possible to use the `<maction>` element with the `actiontype` value set to `"statusline"` in order to override the text of the browser statusline. In particular, this could be used to hide the URL text of an untrusted `href` link. This has been removed in MathML Core and the `<maction>` element essentially behaves like an `<mrow>` container with extra style.

## Conformance

### Document conventions

Conformance requirements are expressed with a combination of descriptive assertions and RFC 2119 terminology. The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this document are to be interpreted as described in RFC 2119. However, for readability, these words do not appear in all uppercase letters in this specification.

All of the text of this specification is normative except sections explicitly marked as non-normative, examples, and notes. [[RFC2119]].

Examples in this specification are introduced with the words “for example” or are set apart from the normative text with `class="example"`, like this:

This is an example of an informative example.

Informative notes begin with the word “Note” and are set apart from the normative text with `class="note"`, like this:

Note, this is an informative note.

Advisements are normative sections styled to evoke special attention and are set apart from other normative text with `<strong class="advisement">`, like this: UAs MUST provide an accessible alternative.