copyright 2014 Dr. Carol JVF Burns

$\rm \TeX$ Commands available in MathJax

Korean version of this document

Jump to the alphabetical list of commands

THIS IS A BIG PAGE.
It takes a long time to process (probably about 2–3 minutes).
You can watch the progress in the lower left corner—it loads most reliably if you resist the temptation to click on something before it's done.
I think it's worth the wait (but of course I'm biased).
You can read about why it's so big below.

This document was created in Spring of 2011.
It's processed using the current version of MathJax, via the MathJax Content Distribution Network (CDN).

I (Dr. Carol JVF Burns) have prepared this page to thoroughly familiarize myself with the $\rm\TeX$ commands that are available in MathJax,
and to provide a resource that may be useful to other MathJax users.
Davide Cervone, the lead developer of MathJax, has most generously provided extensive edits,
and this page is greatly improved due to his efforts; I owe him countless thanks.
All mistakes on this page are my own (and I welcome suggestions and corrections):  

MathJax allows a syntax modeled on both $\rm\TeX$ and $\rm\LaTeX$.
Therefore, web authors can use familiar and concise commands when creating mathematics with MathJax.


Alphabetical List of $\rm\TeX$ Commands available in MathJax

symbols
A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z
environments

Know the shape of a character that you want, but not its name?   Draw it here!

Depending on your configuration, to get AMSsymbols or AMSmath, you may need to load some extensions in MathJax.Hub.Config.
For example:
extensions: ["tex2jax.js", "TeX/noErrors.js", "TeX/AMSsymbols.js", "TeX/AMSmath.js"],

symbols
#   indicates numbered arguments in definitions

Example:
\def\specialFrac#1#2{\frac{x + #1}{y + #2}}
\specialFrac{7}{z+3}
yields $$\def\specialFrac#1#2{\frac{x + #1}{y + #2}} \specialFrac{7}{z+3}$$
%   used for a single-line comment;
shows only in the source code;
does not show in the rendered expression

Example (showing the math block delimiters):
$$
% Note: (x+1)^2 is NOT x^2 + 1
(x+1)^2      % original expression
= (x+1)(x+1) % definition of exponent
= x^2 + 2x + 1 % FOIL, combine like terms
$$
yields $$ % Note: (x+1)^2 is NOT x^2 + 1 (x+1)^2 % original expression = (x+1)(x+1) % definition of exponent = x^2 + 2x + 1 % FOIL, combine like terms $$
Internet Explorer caution:
&   used as separators in alignment environments;
used in HTML entity references within math mode;
for a literal ampersand, use \&

Examples:
\begin{matrix}
a & b\cr
c & d
\end{matrix}
yields $\begin{matrix} a & b\cr c & d \end{matrix}$
a &lt; b yields $a<b$
\text{Carol }\&\text{ Julia} yields $\text{Carol }\&\text{ Julia}$
^   used to indicate exponents;
used to indicate superscripts;
used for limits on large operators and in some ‘vertical’ constructions (see examples)
<optional #1> ^ #2
argument #1 is optional;
use braces, as needed, to clarify what is the exponent

Examples:
^i yields $^i$
x^i_2 yields $x^i_2$
{x^i}_2 yields ${x^i}_2$
x^{i_2} yields $x^{i_2}$
x^{i^2} yields $x^{i^2}$
{x^i}^2 yields ${x^i}^2$ Note:   x^i^2 yields an error.
^ax^b yields $^ax^b$
\sum_{n=1}^\infty yields $\sum_{n=1}^\infty$ (inline mode)
\overbrace{x+\cdots+x}
  ^{n\text{ times}}
yields $\overbrace{x+\cdots+x} ^{n\text{ times}}$
_   used to indicate subscripts;
used for limits on large operators and in some ‘vertical’ constructions (see examples)
<optional #1> _ #2
argument #1 is optional;
use braces, as needed, to clarify what is the subscript

Examples:
_2 yields $_2$
x_i^2 yields $x_i^2$
{x_i}^2 yields ${x_i}^2$
x_{i^2} yields $x_{i^2}$
x_{i_2} yields $x_{i_2}$
{x_i}_2 yields ${x_i}_2$ Note:   x_i_2 yields an error.
^a_bx^c_d yields $^a_bx^c_d$
\sum_{n=1}^\infty yields $\sum_{n=1}^\infty$ (inline mode)
\underbrace{x+\cdots+x}
  _{n\text{ times}}
yields $\underbrace{x+\cdots+x} _{n\text{ times}}$
{ }   braces, used for grouping;
for literal braces, use \{ and \}

There are two basic grouping constructs that use braces;
I will refer to them as ‘arguments’ versus ‘braced groups’.
If you're not aware which construct is in force, then you can get unexpected results.
The examples below should clarify.

ARGUMENTS:
In this documentation, arguments are indicated by #1, #2, etc.
An argument is either a single ‘token’ (like ‘a’ or ‘\alpha’), or is a group enclosed in braces.
For example, the   \boldsymbol   command takes an argument, notated by:
\boldsymbol #1
Thus:
\boldsymbol aa yields $\boldsymbol aa$ the first token, ‘a’, becomes bold
\boldsymbol \alpha\alpha yields $\boldsymbol \alpha\alpha$ the first token, ‘\alpha’, becomes bold
\boldsymbol{a\alpha}a\alpha yields $\boldsymbol{a\alpha}a\alpha$ braces have been used to make the argument the group ‘a\alpha’,
so both become bold


BRACED GROUPS:
A ‘braced group’ is a group, enclosed by braces, inside which some behavior is in force.
The   \bf   (boldface) command operates inside a braced group, notated by:
{\bf ... }
Here,  \bf  is a switch, which ‘turns on’ boldface inside the braced group;
boldface ends when the braced group ends.

Sometimes, you may not see the opening ‘{’ that signals the start of a braced group.
In this situation, when does a command (like  \bf ) end?
It ends at whichever occurs first:
  • it is replaced by a competing command (e.g.,  \bf  is replaced by  \rm )
  • the end of math mode (math delimiters form an implicit local group)
Examples:   (explicit braced groups are indicated in red, for your convenience)
\bf ab yields $\bf ab$ turn on boldface;
stays on to end of math mode
{\bf ab}cd yields ${\bf ab}cd$ an explicit braced group is entered;
the ‘cd’ falls outside this group
\bf{ab}cd yields $\bf{ab}cd$ turn on boldface;
stays on to end of math mode;
the braces here are extraneous
{\bf{ab}c}d yields ${\bf{ab}c}d$ boldface operates inside a braced group;
the ‘d’ falls outside this group
{efg\bf{ab}c}d yields ${efg\bf{ab}c}d$ the ‘efg’ occur before boldface is turned on
ab \bf cd \rm ef yields $ab \bf cd \rm ef$ the competing   \rm   replaces boldface
ab \bf cd {\rm ef} gh yields $ab \bf cd {\rm ef} gh$ the ‘gh’ is still in boldface

Make sure you see the difference in the behaviors below:
\boldsymbol{ab}cd yields $\boldsymbol{ab}cd$ \boldsymbol   takes an argument
\bf{ab}cd yields $\bf{ab}cd$ \bf   does not take an argument;
instead, \bf ‘turns on’ boldface behavior
\!   negative thin space;  i.e., it ‘back ups’ a thin space amount

Examples:
\rm IRyields$\rm IR$
\rm I\! Ryields$\rm I\! R$
see also:   \negthinspace
\,
\:
\>
\;
 
\,thin space (normally $\frac 16 = \frac{3}{18}$ of a quad)
\:medium space (normally $\frac 29 = \frac{4}{18}$ of a quad)
\>alternate medium space
\;thick space (normally $\frac 5{18}$ of a quad)

Examples:
normal spacing between letters: $abababab$
using \, between letters: $a\,b\,a\,b\,a\,b\,a\,b$
using \: between letters: $a\:b\:a\:b\:a\:b\:a\:b$
using \> between letters: $a\>b\>a\>b\>a\>b\>a\>b$
using \; between letters: $a\;b\;a\;b\;a\;b\;a\;b$

see also:   \thinspace
\   (backslash space)  
control space;
$\rm\TeX$ often ignores spaces, or collapses multiple spaces to a single space.
A control space is used to force $\rm\TeX$ to typeset a space.
class ORD

Examples:
\rm This is a sentence. yields $\rm This is a sentence.$
\rm This\ is\ a\ sentence. yields $\rm This\ is\ a\ sentence.$
\rm This~is~a~sentence. yields $\rm This~is~a~sentence.$
\text{This is a sentence.} yields $\text{This is a sentence.}$
in MathJax, this is the same as:   \nobreakspace,   \space,   ~ (tilde character)
see also:   \text
~   (tilde character)  
In $\rm\TeX$ this is a non-breaking space—i.e., a blank space where $\rm\TeX$ is not allowed to break between lines.
MathJax (unlike $\rm\TeX$) doesn't do any automatic breaking of lines, so MathJax will not break at any space.
The tilde is useful to force a space where MathJax would otherwise collapse or ignore spaces, as illustrated in the examples below.
class ORD
\
Click here to see examples of what happens with very long math in MathJax.

Examples:
\rm Dr. Carol J.V. Fisher yields $\rm Dr. Carol J.V. Fisher$
\rm Dr.~Carol~J.V.~Fisher yields $\rm Dr.~Carol~J.V.~Fisher$
\text{Dr. Carol J.V. Fisher} yields $\text{Dr. Carol J.V. Fisher}$
a b      c d yields $a b c d$
a~b~~~~~~c~d yields $a~b~~~~~~c~d$
in MathJax, this is the same as:   \nobreakspace,   \space,   \ (backslash space)
\# $\#$
literal number sign; literal pound sign;
needed since   #   is used to indicate arguments in definitions
&#x0023;   class ORD
\\$ $\$ $
literal dollar sign;
needed since   $   may (optionally) be used to delimit math mode

Dollar sign outside of math mode:
&#x0024;   class ORD
\% $\%$
literal percent sign;
needed since   %   is used to begin a single-line comment
&#x0025;   class ORD
\& $\&$
literal ampersand;
needed since ampersands are used as separators in alignment environments
and for HTML entity references inside math mode
&#x0026;   class ORD

see also:   \And
\\   line separator in alignment modes and environments

Example:
\begin{gather}a\\a+b\\a+b+c\end{gather}yields $\begin{gather}a\\a+b\\a+b+c\end{gather}$
For a literal backslash, see \backslash.

in MathJax, these are essentially the same:   \cr,   \newline
\_ $\_$
literal underscore;
needed since underscores are used for subscripts
&#x005F;   class ORD

Examples:
a_2yields$a_2$
a\_2yields$a\_2$
\{ \} $\{\ \}$
literal braces;
needed since braces are used for grouping in math mode;
non-stretchy when used alone; stretchy when used with   \left   or   \right
\{ is class OPEN
\} is class CLOSE

Examples:
{1,2,3}yields${1,2,3}$
\{1,2,3\}yields$\{1,2,3\}$
\left\{\frac ab,c\right\}yields$\left\{\frac ab,c\right\}$
see also:   \brace,   \lbrace,   \rbrace
| $|$
pipe character; vertical bar; absolute value;
non-stretchy when used alone; stretchy when used with   \left   or   \right
class ORD

Examples:
|x|yields$|x|$
|\frac ab|yields$|\frac ab|$
\left|\frac ab\right|yields$\left|\frac ab\right|$
\{x | x\in\Bbb Z\}yields$\{x | x\in\Bbb Z\}$
\{x\,|\,x\in\Bbb Z\}yields$\{x\,|\,x\in\Bbb Z\}$

see also:   \lvert,   \rvert,   \vert
\| $\|$
double pipe character; double vertical bar; norm;
non-stretchy when used alone; stretchy when used with   \left   or   \right
&#x2225;   class ORD

Examples:
\|x\|yields$\|x\|$
\|\frac ab\|yields$\|\frac ab\|$
\left\|\frac ab\right\|yields$\left\|\frac ab\right\|$
see also:   \lVert,   \rVert,   \Vert
( ) $(\ )$
parentheses;
non-stretchy when used alone; stretchy when used with   \left   or   \right
( is class OPEN;
) is class CLOSE

Examples:
(\frac ab,c)yields$(\frac ab,c)$
\left(\frac ab,c\right)yields$\left(\frac ab,c\right)$
. $.$
period; decimal point class PUNCT

In some math environments (but not all):
With numbers on either side, there is no surrounding space: 3.14 yields $3.14$
With non-numeric characters, there is a slight amount of space on right: a.b yields $a.b$
To suppress this space, enclose the ‘.’ in braces: a{.}b yields $a{.}b$
/ $/$
forward slash;
can be used to denote division
class ORD

Example:
a/b yields $a/b$
+ $+$
plus symbol;
e.g., used for addition
class BIN

Example:
a+b yields $a+b$
- $-$
minus symbol;
e.g., used for subtraction
class BIN

Example:
a-b yields $a-b$
-b yields $-b$ in most cases, proper spacing is achieved
to denote an opposite
\text{first: } -a\star b yields $\text{first: } -a\star b$ an unusual situation;
spacing is not optimal
\text{first: } {-}a\star b yields $\text{first: } {-}a\star b$ in such cases, you can put the minus sign
(or, the group  -a ) inside braces
to suppress extra space
[ ] $[\ ]$
(square) brackets;
non-stretchy when used alone; stretchy when used with   \left   or   \right
[ is class OPEN;
] is class CLOSE

Examples:
[\frac ab,c]yields$[\frac ab,c]$
\left[\frac ab,c\right]yields$\left[\frac ab,c\right]$

see also:   \brack,   \lbrack,   \rbrack
= $=$
equal; equals class REL

see also:   \ne,   \neq
' $'$
prime symbol class ORD

Example:
f(x) = x^2,\ 
f'(x) = 2x,\ 
f''(x) = 2
yields $f(x) = x^2,\ f'(x) = 2x,\ f''(x) = 2$
see also:   \prime
A
\above   general command for making fractions;
gives control over thickness of horizontal fraction bar
{ <subformula1> \above <dimen> <subformula2> }
Creates a fraction:
numerator:   subformula1
denominator:   subformula2
fraction bar has thickness:   dimen

There are separate local groups for  subformula1  and  subformula2 ; if these local groups are not explicit, then unexpected results may occur, as illustrated in the choose discussion.

Examples:
a+1 \above 1pt b yields $a+1 \above 1pt b$
a \above 1pt b+2 yields $a \above 1pt b+2$
{a+1 \above 1.5pt b+2}+c yields ${a+1 \above 1.5pt b+2}+c$
see also:   \abovewithdelims,   \atop,   \atopwithdelims,
  \cfrac,   \dfrac,   \frac,   \genfrac,   \over,   \overwithdelims
\abovewithdelims   general command for making fractions;
gives control over thickness of horizontal fraction bar;
specifies left and right enclosing delimiters
{ <subformula1> \abovewithdelims <delim1> <delim2> <dimen> <subformula2> }
Creates a fraction:
numerator:   subformula1
denominator:   subformula2
fraction bar has thickness:   dimen
delim1   is put before the fraction
delim2   is put after the fraction
For an empty delimiter, use ‘.’ in place of the delimiter.

There are separate local groups for  subformula1  and  subformula2 ; if these local groups are not explicit, then unexpected results may occur, as illustrated in the choose discussion.

Examples:
a+1 \abovewithdelims [ ] 1pt b yields $a+1 \abovewithdelims [ ] 1pt b$
{a \abovewithdelims . | 1.5pt b+2}_{a=3} yields ${a \abovewithdelims . | 1.5pt b+2}_{a=3}$
{a+1 \abovewithdelims \{ \} 1pt b+2}+c yields ${a+1 \abovewithdelims \{ \} 1pt b+2}+c$
see also:     \above,   \atop,   \atopwithdelims,
  \cfrac,   \dfrac,   \frac,   \genfrac,   \over,   \overwithdelims
\acute $\acute{}$ &#x02CA;
acute accent
\acute #1
Usually, #1 is a single letter;  otherwise, accent is centered over argument.

Examples:
\acute e yields $\acute e$
\acute E yields $\acute E$
\acute eu yields $\acute eu$
\acute{eu} yields $\acute{eu}$
\aleph $\aleph$
Hebrew letter aleph;
commonly used for the cardinality of the real numbers
&#x2135;   class ORD
\alpha $\alpha$
lowercase Greek letter alpha &#x03B1;   class ORD
\amalg $\amalg$
this symbol is often used for co-products &#x2A3F;   class BIN
\And $\And$
ampersand &#x0026;   class ORD

see also:   \&
\angle $\angle$
&#x2220;   class ORD
\approx $\approx$
&#x2248;   class REL
\approxeqAMSsymbols
$\approxeq$
&#x224A;   class REL
\arccos $\arccos$
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples

If alternate notation is desired, define:
\def\arccosAlt{\cos^{-1}}   so that   $\arccosAlt(x)$   yields   $\def\arccosAlt{\cos^{-1}} \arccosAlt(x)$
class OP
\arcsin $\arcsin$
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples

If alternate notation is desired, define:
\def\arcsinAlt{\sin^{-1}}   so that   $\arcsinAlt(x)$   yields   $\def\arcsinAlt{\sin^{-1}} \arcsinAlt(x)$
class OP
\arctan $\arctan$
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples

If alternate notation is desired, define:
\def\arctanAlt{\tan^{-1}}   so that   $\arctanAlt(x)$   yields   $\def\arctanAlt{\tan^{-1}} \arctanAlt(x)$
class OP
\arg $\arg$
the complex argument function;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples
class OP
\array   a synonym for  \matrix 
\array{ <math> & <math> ... \cr <repeat as needed> }
alignment occurs at the ampersands;
a double-backslash can be used in place of the  \cr ;
the final   \\   or   \cr   is optional

Example:
\array{ a & b+1 \cr c+1 & d } yields $\array{ a & b+1 \cr c+1 & d }$

see also:   \matrix
\arrowvert $\arrowvert$
not intended for direct use;
used internally to create stretchy delimiters
&#x23D0;   class ORD

see also:   |,   \vert,   \lvert,   \rvert,
\Arrowvert $\Arrowvert$
not intended for direct use;
used internally to create stretchy delimiters
&#x2016;   class PUNCT

see also:   \|,   \Vert,   \lVert,   \rVert
\ast $\ast$
asterisk &#x2217;   class BIN
\asymp $\asymp$
asymptotic &#x224D;   class REL
\atop   general command for making a fraction-like structure, but without the horizontal fraction bar
{ <subformula1> \atop <subformula2> }
Creates a fraction-like structure:
‘numerator’   subformula1
’denominator’   subformula2

There are separate local groups for  subformula1  and  subformula2 ; if these local groups are not explicit, then unexpected results may occur, as illustrated in the choose discussion.

Examples:
a \atop b yields $a \atop b$
a+1 \atop b+2 yields $a+1 \atop b+2$
{a+1 \atop b+2}+c yields ${a+1 \atop b+2}+c$
see also:     \above,   \abovewithdelims,   \atopwithdelims,
  \cfrac,   \dfrac,   \frac,   \genfrac,   \over,   \overwithdelims
\atopwithdelims   general command for making a fraction-like structure, but without the horizontal fraction bar;
specifies left and right enclosing delimiters
{ <subformula1> \atopwithdelims <delim1> <delim2> <subformula2> }
Creates a fraction-like structure:
‘numerator’   subformula1
‘denominator’   subformula2
delim1   is put before the structure
delim2   is put after the structure
For an empty delimiter, use ‘.’ in place of the delimiter.

There are separate local groups for  subformula1  and  subformula2 ; if these local groups are not explicit, then unexpected results may occur, as illustrated in the choose discussion.

Examples:
a \atopwithdelims [ ] b yields $a \atopwithdelims [ ] b$
a+1 \atopwithdelims . | b+2 yields $a+1 \atopwithdelims . | b+2$
{a+1 \atopwithdelims \{ \} b+2}+c yields ${a+1 \atopwithdelims \{ \} b+2}+c$
see also:     \above,   \abovewithdelims,   \atop,
  \cfrac,   \dfrac,   \frac,   \genfrac,   \over,   \overwithdelims
B
\backepsilon AMSsymbols
$\backepsilon$
  &#x220D;   class REL
\backprimeAMSsymbols
$\backprime$
see also:   \prime &#x2035;   class ORD
\backsimAMSsymbols
$\backsim$
  &#x223D;   class REL
\backsimeqAMSsymbols
$\backsimeq$
  &#x22CD;   class REL
\backslash $\backslash$
see also:   \setminus &#x2216;
\bar $\bar{}$
bar accent (non-stretchy) &#x02C9;
\bar #1
Usually, #1 is a single letter;  otherwise, bar is centered over argument.

Examples:
\bar x yields $\bar x$
\bar X yields $\bar X$
\bar xy yields $\bar xy$
\bar{xy} yields $\bar{xy}$
\barwedge AMSsymbols
$\barwedge$
  &#x22BC;   class BIN
\Bbb  
blackboard-bold for uppercase letters and lowercase ‘k’;
if lowercase blackboard-bold letters are not available, then they are typeset in a roman font
class ORD
\Bbb #1
Whether lower-case letters are displayed in blackboard-bold, or not, depends on the fonts being used.
The MathJax web-based fonts don't have lowercase blackboard-bold, but the STIX fonts do;
so users with the STIX fonts installed will be able to display lowercase blackboard-bold letters.

Examples:
\Bbb R yields $\Bbb R$
\Bbb ZR yields $\Bbb ZR$
\Bbb{AaBbKk}Cc yields $\Bbb{AaBbKk}Cc$
\Bbb{ABCDEFGHIJKLMNOPQRSTUVWXYZ} yields $\Bbb{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$

see also:   \mathbb
\BbbkAMSsymbols
$\Bbbk$
blackboard-bold lowercase k &#x006B;   class ORD
\becauseAMSsymbols
$\because$
  &#x2235;   class REL
\begin   used in   \begin{xxx} ... \end{xxx}   environments
\beta $\beta$
lowercase Greek letter beta &#x03B2;   class ORD
\bethAMSsymbols
$\beth$
Hebrew letter beth &#x2136;   class ORD
\betweenAMSsymbols
$\between$
  &#x226C;   class REL
\bf  
turns on boldface;  affects uppercase and lowercase letters, and digits class ORD
{\bf ... }
Examples:
\bf AaBb\alpha\beta123 yields $\bf AaBb\alpha\beta123$
{\bf A B} A B yields ${\bf A B} A B$
\bf AB \rm CD yields $\bf AB \rm CD$
\bf{AB}CD yields $\bf{AB}CD$

see also:   \mathbf,   \boldsymbol
\Bigg
\bigg
\Big
\big
  used to obtain various-sized delimiters;
may be followed by any of these Variable-Sized Delimiters

Examples:
$\Bigg[$ $\bigg[$ $\Big[$ $\big[$ $[$
\Bigg[ \bigg[ \Big[ \big[ [
2.470 em 2.047 em 1.623 em 1.2 em  
\Biggl \Biggm \Biggr
\biggl \biggm \biggr
\Bigl \Bigm \Bigl
\bigl \bigm \bigr
  Used to obtain various-sized delimiters, with a left/right/middle context;
may be followed by any of these Variable-Sized Delimiters.

The ‘l’ (left), ’m’ (middle), and ‘r’ (right) specifications
may make reading the source code more meaningful,
especially when there are delimiters inside delimiters.

Whereas (say)  \Bigg  produces results of class ORD, we have:
  •  \Biggl  produces results of class OPEN
  •  \Biggr  produces results of class CLOSE
  •  \Biggm  produces results of class REL
The spacing for these differ (but may not always be apparent, as it depends on the class of what is next to it).
For example,  $x\big| y$  ($\,x\big| y\,$) has less space than  $x\bigm| y$  ($\,x\bigm| y\,$).
Therefore, these commands affect typeset results in a fundamental way;
it is best to use the form appropriate for the position of the desired delimiter.
\bigcap $\bigcap$
changes size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
&#x22C2;   class OP
\bigcirc $\bigcirc$
  &#x25EF;   class BIN
\bigcup $\bigcup$
changes size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
&#x22C3;   class OP
\bigodot
\bigoplus
\bigotimes
$\bigodot$
$\bigoplus$
$\bigotimes$
all change size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
&#x2A00;   class OP
&#x2A01;   class OP
&#x2A02;   class OP
\bigsqcup $\bigsqcup$
changes size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
&#x2A06;   class OP
\bigstarAMSsymbols
$\bigstar$
  &#x2605;   class ORD
\bigtriangledown $\bigtriangledown$
  &#x25BD;   class BIN
\bigtriangleup $\bigtriangleup$
&#x25B3;   class REL
\biguplus $\biguplus$
changes size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
&#x2A04;   class OP
\bigvee $\bigvee$
changes size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
&#x22C1;   class OP
\bigwedge $\bigwedge$
changes size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
&#x22C0;   class OP
\binomAMSmath
  notation commonly used for binomial coefficients
\binom #1 #2
Examples:
\binom n k yields (inline mode) $\binom nk$
\binom n k yields (display mode) $\displaystyle\binom nk$
\binom{n-1}k-1 yields $\binom{n-1}k-1$
\binom{n-1}{k-1} yields $\binom{n-1}{k-1}$
see also:   \binom,   \choose,   \dbinom,   \tbinom
\blacklozengeAMSsymbols
$\blacklozenge$
  &#x29EB;   class ORD
\blacksquareAMSsymbols
$\blacksquare$
  &#x25A0;   class ORD
\blacktriangle
\blacktriangledown
both AMSsymbols
$\blacktriangle$
$\blacktriangledown$
&#x25B2;   class ORD
&#x25BC;   class ORD
\blacktriangleleft
\blacktriangleright
both AMSsymbols
$\blacktriangleleft$
$\blacktriangleright$
&#x25C0;   class BIN
&#x25B6;   class BIN
\bmod $\bmod$
properly spaced as a binary operator class BIN
\boldsymbol  
as opposed to  \bf  and  \mathbf ,
\boldsymbol  applies to nearly all symbols, not just letters and numbers
class ORD
\boldsymbol #1
Examples:
\boldsymbol aa yields $\boldsymbol aa$
\boldsymbol \alpha\alpha yields $\boldsymbol \alpha\alpha$
\boldsymbol{a\alpha}a\alpha yields $\boldsymbol{a\alpha}a\alpha$
\boldsymbol{a+2+\alpha+\frac{x+3}{\beta+4}} yields $\boldsymbol{a+2+\alpha+\frac{x+3}{\beta+4}}$
\mathbf{a+2+\alpha+\frac{x+3}{\beta+4}} yields $\mathbf{a+2+\alpha+\frac{x+3}{\beta+4}}$
see also:   \bf,   \mathbf
\bot $\bot$
  &#x22A5;   class ORD
\bowtie $\bowtie$
  &#x22C8;   class REL
\BoxAMSsymbols
$\Box$
  &#x25A1;   class ORD
\boxdotAMSsymbols
$\boxdot$
  &#x22A1;   class BIN
\boxedAMSmath
  puts a box around argument; argument is in math mode
\boxed #1
Examples:
\boxed ab yields $\boxed ab$
\boxed{ab} yields $\boxed{ab}$
\boxed{ab\strut} yields $\boxed{ab\strut}$
\boxed{\text{boxed text}} yields $\boxed{\text{boxed text}}$
see also:   \fbox
\boxminusAMSsymbols
\boxplusAMSsymbols
\boxtimesAMSsymbols
$\boxminus$
$\boxplus$
$\boxtimes$
&#x229F;   class BIN
&#x229E;   class BIN
&#x22A0;   class BIN
\brace   creates a braced structure
{ <subformula1> \brace <subformula2> }
Examples:
\brace yields $\brace$
a\brace b yields $a\brace b$
a+b+c\brace d+e+f yields $a+b+c\brace d+e+f$
a+{b+c\brace d+e}+f yields $a+{b+c\brace d+e}+f$
\bracevert  
not intended for direct use;
used internally to create stretchy delimiters
&#x23AA;   class ORD
\brack   creates a bracketed structure
{ <subformula1> \brack <subformula2> }
Examples:
\brack yields $\brack$
a\brack b yields $a\brack b$
a+b+c\brack d+e+f yields $a+b+c\brack d+e+f$
a+{b+c\brack d+e}+f yields $a+{b+c\brack d+e}+f$
\breve $\breve{}$
breve accent &#x02D8;
\breve #1
Usually, #1 is a single letter;  otherwise, accent is centered over argument.

Examples:
\breve e yields $\breve e$
\breve E yields $\breve E$
\breve eu yields $\breve eu$
\breve{eu} yields $\breve{eu}$
\buildrel ... \over ...  
\buildrel <subformula1> \over #1
The result is of class  REL  (binary relation), so it has the spacing of a relation.

Examples:
\buildrel \alpha\beta \over \longrightarrow yields $\buildrel \alpha\beta \over \longrightarrow$
\buildrel \rm def \over {:=} yields $\buildrel \rm def \over {:=}$
\bullet $\bullet$
  &#x2219;   class BIN
\BumpeqAMSsymbols
\bumpeqAMSsymbols
$\Bumpeq$
$\bumpeq$
&#x224E;   class REL
&#x224F;   class REL
C
\cal   class ORD
turns on calligraphic mode;  only affects uppercase letters and digits
{\cal ... }
Examples:
\cal ABCDEFGHIJKLMNOPQRSTUVWXYZ yields $\cal ABCDEFGHIJKLMNOPQRSTUVWXYZ$
\cal 0123456789 yields $\cal 0123456789$
\cal abcdefghijklmnopqrstuvwxyz yields $\cal abcdefghijklmnopqrstuvwxyz$
abcdefghijklmnopqrstuvwxyz yields $abcdefghijklmnopqrstuvwxyz$
{\cal AB}AB yields ${\cal AB}AB$
\cal AB \rm AB yields $\cal AB \rm AB$
\cal{AB}CD yields $\cal{AB}CD$

see also:   \oldstyle,   \mathcal
\cancel   Used to ‘cancel’ (strikeout).
\cancel #1
\bcancel #1
Examples:
\frac{(x+1)\cancel{(x+2)}}{3\cancel{(x+2)}} yields $\frac{(x+1)\cancel{(x+2)}}{3\cancel{(x+2)}}$
\frac{\bcancel{\frac13}}{\bcancel{\frac13}} = 1 yields $\frac{\bcancel{\frac13}}{\bcancel{\frac13}} = 1$
\CapAMSsymbols
$\Cap$ &#x22D2;   class BIN

see also:  \bigcap,   \cap,   \Cup,   \cup,   \doublecap,  \doublecup
\cap $\cap$ &#x2229;   class BIN

see also:  \bigcap,  \Cap,   \Cup,   \cup,   \doublecap,  \doublecup
\cases   class OPEN
for piecewise-defined functions
\cases{ <math> & <math> \cr <repeat as needed> }
a double-backslash can be used in place of   \cr ;
the final   \\   or   \cr   is optional

In $\,\rm\TeX\,$, the second column is automatically in text-mode, while in MathJax it is in math-mode.
This behavior will be changed to be consistent with $\,\rm\TeX\,$ in a future release of MathJax.

Example:
|x| = 
\cases{
x  & \text{if } x\ge 0\cr
-x & \text{if } x\lt 0
}
yields $|x| = \cases{ x & \text{if } x\ge 0\cr -x & \text{if } x\lt 0 } $
\cdot $\cdot$ &#x22C5;   class BIN
centered dot

Examples:
a\cdot byields$a\cdot b$
a\cdotp byields$a\cdotp b$
a\centerdot byields$a\centerdot b$
see also:   \cdotp,   \cdots,   \centerdot
\cdotp $\cdotp$ &#x22C5;   class PUNCT
centered dot, punctuation symbol

Examples:
\rm s \cdot h yields $\rm s \cdot h$
\rm s \cdotp h yields $\rm s \cdotp h$
see also:   \cdot,   \centerdot
\cdots $\cdots$ &#x22EF;   class INNER
centered dots;   dot dot dot

Example:
x_1 + \cdots + x_n   yields   $x_1 + \cdots + x_n$

see also:   \dots,   \ldots
\centerdotAMSsymbols
$\centerdot$ &#x22C5;   class BIN
centered dot

Examples:
a\cdot byields$a\cdot b$
a\cdotp byields$a\cdotp b$
a\centerdot byields$a\centerdot b$
see also:   \cdot,   \cdotp
\cfracAMSmath
  use for continued fractions
\cfrac #1 #2
Examples:
\frac{2}{1+\frac{2}{1+\frac{2}{1}}} yields $\frac{2}{1+\frac{2}{1+\frac{2}{1}}}$
\cfrac{2}{1+\cfrac{2}{1+\cfrac{2}{1}}} yields $\cfrac{2}{1+\cfrac{2}{1+\cfrac{2}{1}}}$
see also:     \above,   \abovewithdelims,   \atop,   \atopwithdelims,
  \dfrac,   \frac,   \genfrac,   \over,   \overwithdelims
\check $\check{}$ &#x02C7;
check accent
\check #1
Usually, #1 is a single letter;  otherwise, accent is centered over argument.

Examples:
\check o yields $\check o$
\check O yields $\check O$
\check oe yields $\check oe$
\check{oe} yields $\check{oe}$
\checkmarkAMSsymbols
$\checkmark$ #x2713;   class ORD
\chi $\chi$ &#x03C7;   class ORD
lowercase Greek letter chi
\choose   notation commonly used for binomial coefficients;
different versions for inline and display modes
{ <subformula1> \choose <subformula2> }
There are separate local groups for  subformula1  and  subformula2 ;
if these local groups are not explicit, then unexpected results may occur, as illustrated next.

Examples (showing the math delimiters):
$\displaystyle
n+1
\choose
k+2
$
yields $\displaystyle n+1 \choose k+2$ Without an explicit braced group, the local group for  subformula1  extends back to the opening math delimiter.
That is, this code is interpreted as (color added for emphasis): ${\displaystyle n+1}\choose{k+2}$
Now it is clear that only the  n+1  is affected by the  \displaystyle  switch.
$\displaystyle
{n+1
\choose
k+2}
$
yields $\displaystyle {n+1 \choose k+2}$ Here, an explicit braced group is used for the  \choose  command, making both subformulas clear—and the expected result is obtained.
Note that it may appear that  \displaystyle  is taking an argument, but this is not the case: instead,  \displaystyle  acts as a switch which turns on display mode, and the entire  choose  command is affected.
Examples (showing math delimiters):
$n+1 \choose k+2$ yields $n+1 \choose k+2$
$$n+1 \choose k+2$$ yields $$n+1 \choose k+1$$
$1+{n \choose 2}+k$ yields $1+{n \choose 2}+k$
see also:   \binom,   \dbinom,   \tbinom
\circ $\circ$ &#x2218;   class BIN

Examples:

(f\circ g)(x) = f(g(x)) yields $(f\circ g)(x) = f(g(x))$
45^\circ yields $45^\circ$
\circeqAMSsymbols
$\circeq$ &#x2257;   class REL
\circlearrowleftAMSsymbols
\circlearrowrightAMSsymbols
$\circlearrowleft$
$\circlearrowright$
&#x21BA;counterclockwise class REL
&#x21BB;clockwise class REL
\circledastAMSsymbols
\circledcircAMSsymbols
\circleddashAMSsymbols
$\circledast$
$\circledcirc$
$\circleddash$
&#x229B;circled asteriskclass BIN
&#x229A;circled circleclass BIN
&#x229D;circled dashclass BIN
\circledRAMSsymbols
\circledSAMSsymbols
$\circledR$
$\circledS$
&#x00AE;circled Rclass ORD
&#x24C8;circled Sclass ORD
\class [HTML]
  non-standard; extension is loaded automatically when used;
used to specify a CSS class for styling mathematics
\class #1 #2
where:
  • #1  is a CSS class name (without quotes)
  • #2  is the mathematics to be styled
Example:
Suppose this CSS style information is provided outside of math mode:
<style type="text/css">
.smHighlightRed {
font-size:small;
background-color:yellow;
color:red;
}
</style>
Then,
ab\class{smHighlightRed}{cdef}gh yields $ab\class{smHighlightRed}{cdef}gh$

\clubsuit $\clubsuit$ &#x2663;   class ORD
see also:   \diamondsuit,   \heartsuit,   \spadesuit
\colon $\colon$ &#x003A;   class PUNCT
a colon, treated as a punctuation mark (instead of a relation)

Examples:
f:A\to Byields$f:A\to B$
f\colon A\to Byields$f\colon A\to B$
\color    used to specify a color in mathematics
\color #1 #2
where:
#1   is the desired color
#2   is the mathematics to be colored

This works differently from standard $\,\rm\LaTeX\,$ (where  \color  is a switch).
In a future version of MathJax, it will be possible to load an extension to make the command behave like the $\,\rm\LaTeX\,$ version.

Examples:
\color{red}{ \frac{1+\sqrt{5}}{2} } yields $\color{red}{ \frac{1+\sqrt{5}}{2} }$
\color{#0000FF}AB yields $\color{#0000FF}AB$
\complementAMSsymbols
$\complement$ &#x2201;   class ORD
\cong $\cong$ &#x2245;   class REL
congruent

see also:   \ncong
\coprod $\coprod$ &#x2210;   class OP
coproduct
\cos $\cos$ class OP
cosine;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples

Examples:
\cos x yields $\cos x$
\cos(2x-1) yields $\cos(2x-1)$

see also:   \sin
\cosh $\cosh$ class OP
hyperbolic cosine;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples
hyperbolic cosine

Examples:
\cosh x yields $\cosh x$
\cosh(2x-1) yields $\cosh(2x-1)$

see also:   \sinh
\cot $\cot$ class OP
cotangent;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples

Examples:
\cot x yields $\cot x$
\cot(2x-1) yields $\cot(2x-1)$
see also:   \tan
\coth $\coth$ class OP
hyperbolic cotangent;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples

Examples:
\coth x yields $\coth x$
\coth(2x-1) yields $\coth(2x-1)$
\cr   carriage return;
line separator in alignment modes and environments

in MathJax, these are essentially the same:   \\,   \newline
\csc $\csc$ class OP
cosecant
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples

Examples:
\csc x yields $\csc x$
\csc(2x-1) yields $\csc(2x-1)$
see also:   \sec
\cssId [HTML]
  non-standard;   class ORD;   extension is loaded automatically when used;
used to set a MathML element's ID attribute, so it can be accessed dynamically
(e.g., to add an event handler, add CSS styling, or set display status)
\cssId #1 #2
where:
  • #1  is an ID attribute (without quotes)
  • #2  is the mathematics to be identified by the ID
Example:

Suppose this HTML and Javascript is provided outside of math mode:
<button type="button" onclick="turnRed();">
Click button to turn something red
</button>

<script type="text/javascript">
function turnRed() {
document.getElementById('testID').style.color = "red";
}
</script>
Suppose further that the following MathJax code is provided:
$$
abc
\cssId{testID}{def\text{ Something will turn red! }ghi}
jkl
$$
Then, this HTML/Javascript/MathJax produces:


$$abc\cssId{testID}{def\text{ Something will turn red! }ghi}jkl$$ A more meaningful example (with well-commented source code) is provided by Design Science, Inc.,
and shows how you can display the steps in a proof one line at a time.
\CupAMSsymbols
$\Cup$ &#x22D3;   class BIN

see also:   \bigcup,   \Cap,   \cap,   \cup,   \doublecap,  \doublecup
\cup $\cup$ &#x222A;   class BIN

see also:   \bigcup,   \Cap,   \cap,   \Cup,   \doublecap,  \doublecup
\curlyeqprecAMSsymbols
\curlyeqsuccAMSsymbols
$\curlyeqprec$
$\curlyeqsucc$
&#x22DE;class REL
&#x22DF;class REL
\curlyveeAMSsymbols
\curlywedgeAMSsymbols
$\curlyvee$
$\curlywedge$
&#x22CE;class BIN
&#x22CF;class BIN
\curvearrowleftAMSsymbols
\curvearrowrightAMSsymbols
$\curvearrowleft$
$\curvearrowright$
&#x21B6;counterclockwiseclass REL
&#x21B7;clockwiseclass REL
D
\dagger
\ddagger
$\dagger$
$\ddagger$
&#x2020;daggerclass BIN
&#x2021;double daggerclass BIN
\dalethAMSsymbols
$\daleth$ &#x2138;   class ORD
Hebrew letter daleth
\dashleftarrowAMSsymbols
\dashrightarrowAMSsymbols
$\dashleftarrow$
$\dashrightarrow$
&#x21E0;dashed left arrow; non-stretchyclass REL
&#x21E2;dashed right arrow; non-stretchyclass REL
\dashv $\dashv$ &#x22A3;   class REL
\dbinomAMSmath
  notation commonly used for binomial coefficients;
display version (in both inline and display modes)
\dbinom #1 #2
Examples:
\dbinom n k yields (inline mode) $\dbinom n k$
\dbinom n k yields (display mode) $\displaystyle\dbinom n k$
\dbinom{n-1}k-1 yields $\dbinom{n-1}k-1$
\dbinom{n-1}{k-1} yields $\dbinom{n-1}{k-1}$
see also:   \binom,   \choose,   \tbinom
\dot 
\ddot 
\dddotAMSmath
\ddddotAMSmath
$\dot{}$
$\ddot{}$
$\dddot{}$
$\ddddot{}$
&#x02D9;dot accent
&#x00A8;double dot accent
triple dot accent
quadruple dot accent
\dot #1
\ddot #1
\dddot #1
\ddddot #1
Usually, #1 is a single letter;  otherwise, accent is centered over argument.

Examples:
\dot x yields $\dot x$
\ddot x yields $\ddot x$
\dddot x yields $\dddot x$
\ddddot x yields $\ddddot x$
\ddot x(t) yields $\ddot x(t)$
\ddddot{y(x)} yields $\ddddot{y(x)}$
\ddots $\ddots$ &#x22F1;   class INNER
three diagonal dots
\DeclareMathOperatorAMSmath
  Multi-letter operator names (like $\,\log\,$, $\,\sin\,$, and $\,\lim\,$) are traditionally typeset in a roman font.
\DeclareMathOperator  allows you to define your own operator names;
they are subsequently typeset using the proper font and spacing;
you can control the way that limits appear (see examples below)
\DeclareMathOperator #1 #2
where:
  • #1  is the operator name, including the preceding backslash;
    only letters a–z and A–Z are allowed;
    in particular, no numbers are allowed in operator names
  • #2  is the replacement text for the operator name
A named operator is available in any mathematics that appears after it is defined on the page.

Examples:
myOp(x) yields $myOp(x)$ poor style; the function name should appear in a roman font
\text{myOp}(x) yields $\text{myOp}(x)$ better; a nuisance to type if used frequently
\DeclareMathOperator
  {\myOp}{myOp}
\myOp(x)
yields $\DeclareMathOperator {\myOp}{myOp} \myOp(x)$ best; once an operator is declared, it can be used in any subsequent mathematics
\myOp_a^b(x) yields (inline mode) $\myOp_a^b(x)$ standard subscript and superscript position for inline mode
\myOp_a^b(x) yields (display mode) $\displaystyle\myOp_a^b(x)$ standard subscript and superscript position for display mode
\DeclareMathOperator*
{\myOP}{myOP}
\myOP_a^b(x)
yields (inline mode) $\DeclareMathOperator* {\myOP}{myOP} \myOP_a^b(x)$ operator names are case-sensitive, so  \myOp  is different from  \myOP ;
if displaystyle limits are desired in both inline and display modes, then use DeclareMathOperator*  instead of DeclareMathOperator
\def   for defining your own commands (control sequences, macros, definitions);
must appear (within math delimiters) before it is used;
alternatively, you can define macros using the MathJax configuration options in the  <head>
\def\myCommandName{ <replacement text> }
Example:
\def\myHearts{\color{purple}{\heartsuit}\kern-2.5pt\color{green}{\heartsuit}}
\myHearts\myHearts
yields: $ \def\myHearts{\color{purple}{\heartsuit}\kern-2.5pt\color{green}{\heartsuit}} \myHearts\myHearts $

A definition may take one or more arguments:

Example:
\def\myHearts#1#2{\color{#1}{\heartsuit}\kern-2.5pt\color{#2}{\heartsuit}}
\myHearts{red}{blue}
yields: $ \def\myHearts#1#2{\color{#1}{\heartsuit}\kern-2.5pt\color{#2}{\heartsuit}} \myHearts{red}{blue} $

see also:   \newcommand
\deg $\deg$ class OP
degree;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples
\Delta
\delta
$\Delta$
$\delta$
&#x0394;uppercase Greek letter deltaclass ORD
&#x03B4;lowercase Greek letter deltaclass ORD
see also:   \varDelta
\det $\det$ class OP
determinant;
does not change size;
default limit placement can be changed using  \limits  and  \nolimits;
does not change size;
see the Big Operators Table for more examples
Examples:
\det_{\rm sub}yields (inline mode)$\det_{\rm sub}$
\det_{\rm sub}yields (display mode)$\displaystyle\det_{\rm sub}$
\det\limits_{\rm sub}yields (inline mode)$\det\limits_{\rm sub}$
\det\nolimits_{\rm sub}yields (display mode)$\displaystyle\det\nolimits_{\rm sub}$
\dfracAMSmath
  fractions;
display version (in both inline and display modes)
\dfrac #1 #2
Examples:
\dfrac a b yields (inline mode) $\dfrac a b$
\dfrac a b yields (display mode) $\displaystyle\dfrac a b$
\frac a b yields (inline mode) $\frac a b$
\dfrac{a-1}b-1 yields $\dfrac{a-1}b-1$
\dfrac{a-1}{b-1} yields $\dfrac{a-1}{b-1}$
see also:     \above,   \abovewithdelims,   \atop,   \atopwithdelims,
  \cfrac,   \frac,   \genfrac,   \over,   \overwithdelims
\diagdownAMSsymbols
\diagupAMSsymbols
$\diagdown$
$\diagup$
&#x2572;diagonal down (from left to right)class ORD
&#x2571;diagonal up (from left to right)class ORD
\DiamondAMSsymbols
\diamond 
$\Diamond$
$\diamond$
&#x25CA;large diamondclass ORD
&#x22C4;small diamondclass BIN
\diamondsuit $\diamondsuit$ &#x2662;   class ORD

see also:   \clubsuit,   \heartsuit,   \spadesuit
\digammaAMSsymbols
$\digamma$ &#x03DD;   class ORD
\dim $\dim$ class OP
dimension;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples
\displaylines   to display any number of centered formulas (without any alignment)
\displaylines{ <math> \cr <repeat as needed> }
a double-backslash can be used in place of the \cr;
the final   \\   or   \cr   is optional

Example:
\displaylines{
a = a\\
\text{if } a=b \text{ then } b=a\\
\text{if } a=b \text{ and } b=c \text{ then } a=c
}
yields $ \displaylines{ a = a\\ \text{if } a=b \text{ then } b=a\\ \text{if } a=b \text{ and } b=c \text{ then } a=c } $
see also:   gather
\displaystyle   class ORD
used to over-ride automatic style rules and force display style;
stays in force until the end of math mode or the braced group, or until another style is selected
{ \displaystyle ... }
Example:
In inline mode:
\frac ab+\displaystyle\frac ab+\textstyle\frac ab
+\scriptstyle\frac ab+\scriptscriptstyle\frac ab

yields:
$\frac ab + \displaystyle\frac ab+\textstyle\frac ab+\scriptstyle\frac ab+\scriptscriptstyle\frac ab$

Example:
In inline mode:
\frac ab + {\displaystyle \frac cd + \frac ef} + \frac gh
yields
$\frac ab + {\displaystyle \frac cd + \frac ef} + \frac gh$

Example:
In inline mode:
\frac ab + \displaystyle{\frac cd + \frac ef} + \frac gh
yields
$\frac ab + \displaystyle{\frac cd + \frac ef} + \frac gh$

see also:   \textstyle,   \scriptstyle,   \scriptscriptstyle
\div $\div$ &#x00F7;   class BIN
division symbol
\divideontimesAMSsymbols
$\divideontimes$ &#x22C7;   class BIN
\DoteqAMSsymbols
\doteq 
$\Doteq$
$\doteq$
&#x2251;class REL
&#x2250;class REL
\dotplusAMSsymbols
$\dotplus$ &#x2214;   class BIN
\dots $\dots$ &#x2026;   class INNER
lower dots;   ellipsis;   ellipses;   dot dot dot

In $\,\rm\LaTeX\,$,  \dots  chooses either  \cdots  or  \ldots  depending on the context;
MathJax, however, always gives lower dots.

Examples:
x_1, \dots, x_n yields $x_1, \dots, x_n$
x_1 + \dots + x_n yields $x_1 + \dots + x_n$
x_1 + \dotsb + x_n yields $x_1 + \dotsb + x_n$
x_1 + \cdots + x_n yields $x_1 + \cdots + x_n$

see also:   \cdots,   \ldots,   \dotsb,   \dotsc,   \dotsi,   \dotsm,   \dotso
\dotsb
\dotsc
\dotsi
\dotsm
\dotso
 
&#x22EF;\dotsbclass INNERdots with binary operations and relations$x_1 + x_2 +\dotsb + x_n$
&#x2026;\dotscclass INNERdots with commas$x_1,x_2,\dotsc,x_n$
&#x22EF;\dotsiclass INNERdots with integrals$\int_{A_1}\int_{A_2}\dotsi\int_{A_n}$
&#x22EF;\dotsmclass INNERdots with multiplication$x_1x_2\dotsm x_n$
&#x2026;\dotsoclass INNERother dots$A_1\dotso A_n$

see also:   \cdots,   \dots,   \ldots
\doublebarwedgeAMSsymbols
$\doublebarwedge$ &#x2A5E;   BIN
\doublecapAMSsymbols
\doublecupAMSsymbols
$\doublecap$
$\doublecup$
&#x22D2;class BIN
&#x22D3;class BIN

see also:   \Cap,   \Cup,   \cap,   \cup
\downarrow
\Downarrow
$\downarrow$
$\Downarrow$
&#x2193;down arrow; non-stretchyclass REL
&#x21D3;double down arrow; non-stretchyclass REL
\downdownarrowsAMSsymbols
$\downdownarrows$ &#x21CA;   class REL
down down arrows; non-stretchy
\downharpoonleftAMSsymbols
\downharpoonrightAMSsymbols
$\downharpoonleft$
$\downharpoonright$
&#x21C3;down harpoon left; non-stretchyclass REL
&#x21C2;down harpoon right; non-stretchyclass REL
see also:   \leftharpoondown,   \leftharpoonup
E
\ell $\ell$ &#x2113;   class ORD
\emptyset $\emptyset$ &#x2205;   class ORD
empty set

see also:   \varnothing
\end   used in   \begin{xxx} ... \end{xxx}   environments
\enspace   \enspace   is a 0.5em space

Example:
|\enspace|\enspace| yields $|\enspace|\enspace|$
\epsilon $\epsilon$ &#x03F5;   class ORD
lowercase Greek letter epsilon

see also:   \varepsilon
\eqalign   equation alignment;
for aligning multi-line displays at a single place
\eqalign{ <math> & <math> \cr <repeat as needed> }
the ampersand is placed where alignment is desired;
a double-backslash can be used in place of the  \cr ;
the final   \\   or   \cr   is optional;
supports only a single \tag, which is vertically centered

Example:
\eqalign{
3x - 4y &= 5\cr
x  +  7 &= -2y
}
yields: $$ \eqalign{ 3x - 4y &= 5\cr x + 7 &= -2y } $$ Example:
A  <math>  component may be empty:
\eqalign{
(a+b)^2 &= (a+b)(a+b) \\
        &= a^2 + ab + ba + b^2 \\
        &= a^2 + 2ab + b^2
}
yields: $$ \eqalign{ (a+b)^2 &= (a+b)(a+b) \\ &= a^2 + ab + ba + b^2 \\ &= a^2 + 2ab + b^2 } $$ Example:
The result of \eqalign is a vertically-centered block;
you can use more than one in the same display:
\left\{
\eqalign{
a &= 1\\
b &= 2\\
c &= 3
}\right\}
\qquad
\eqalign{
ax + by &= c \\
 x + 2y &= 3
 }
yields: $$ \left\{ \eqalign{ a &= 1\\ b &= 2\\ c &= 3 }\right\} \qquad \eqalign{ ax + by &= c \\ x + 2y &= 3 } $$ see also:   \eqalignno,   the align environment,   \tag
\eqalignno   equation alignment with optionally numbered (tagged) lines
\eqalignno{ <math> & <math> & <equation tag> \cr <repeat as needed> }
the first ampersand is placed where alignment is desired;
the second ampersand is used just before a tag;
if there is no tag, then the final   & <equation tag>   is omitted;
a double-backslash can be used in place of the  \cr ;
the final   \\   or   \cr   is optional

Example:
\eqalignno{
3x - 4y &= 5   &(\dagger) \cr
x  +  7 &= -2y &(\ddagger)\cr
      z &= 2
}
yields: $$ \eqalignno{ 3x - 4y &= 5 &(\dagger)\cr x + 7 &= -2y &(\ddagger)\cr z &= 2 } $$ see also:   \eqalign,   \leqalignno,   the align environment
\eqcircAMSsymbols
$\eqcirc$ &#x2256;   class REL
\eqsimAMSsymbols
$\eqsim$ &#x2242;   class REL
\eqslantgtrAMSsymbols
\eqslantlessAMSsymbols
$\eqslantgtr$
$\eqslantless$
&##x2A96;class REL
&##x2A95;class REL
\equiv $\equiv$ &#x2261;   class REL
Error Messages;
page processing log
  When you're working with a MathJax page, you may want to see the log of messages generated during page processing (particularly if something has gone wrong).
To do this, type
javascript:alert(MathJax.Message.Log())
in the browser's location URL box, and then refresh the page.
If the alert box is too big to see the close button, just press ‘enter’ to close the alert box.
\eta $\eta$ &#x03B7;   class ORD
lowercase Greek letter eta
\ethAMSsymbols
$\eth$ &#x00F0;   class ORD
\exists $\exists$ &#x2203;   class ORD
there exists

see also:   \nexists
\exp $\exp$ class OP
exponential function;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples
F
\fallingdotseqAMSsymbols
$\fallingdotseq$ &#x2252;   class REL
falling dot sequence;

see also:   \risingdotseq
\fbox   puts a box around argument; argument is in text mode
equivalent to: \boxed{\text{#1}}
\fbox #1
where #1 is rendered as text

Examples:
\boxed{Hi there!} yields $\boxed{Hi there!}$
\fbox{Hi there!} yields $\fbox{Hi there!}$
see also:   \boxed
\FinvAMSsymbols
$\Finv$ &#x2132;   class ORD
\flat $\flat$ &#x266D;   class ORD
musical flat symbol

see also:   \natural,   \sharp
\forall $\forall$ &#x2200;   class ORD
universal quantifier; for all; for every; for each
\fracAMSmath
  fractions;
displays differently in inline and display modes
\frac #1 #2
Examples:
\frac a b yields (inline mode) $\frac a b$
\frac a b yields (display mode) $\displaystyle\frac a b$
\frac{a-1}b-1 yields $\frac{a-1}b-1$
\frac{a-1}{b-1} yields $\frac{a-1}{b-1}$
see also:   \above,   \abovewithdelims,   \atop,   \atopwithdelims,
  \cfrac,   \dfrac,   \genfrac,   \over,   \overwithdelims
\frak   class ORD
turns on fraktur;  affects uppercase and lowercase letters, and digits
{\frak ... }
Examples:
\frak ABCDEFGHIJKLMNOPQRSTUVWXYZ yields $\frak ABCDEFGHIJKLMNOPQRSTUVWXYZ$
\frak 0123456789 yields $\frak 0123456789$
\frak abcdefghijklmnopqrstuvwxyz yields $\frak abcdefghijklmnopqrstuvwxyz$
{\frak AB}AB yields ${\frak AB}AB$
\frak AB \rm AB yields $\frak AB \rm AB$
{\frak AB \cal AB} AB yields ${\frak AB \cal AB} AB$

see also:   \mathfrak
\frown $\frown$ &#x2322;   class REL

see also:   \smallfrown,   \smallsmile,   \smile
G
\GameAMSsymbols
$\Game$ &#x2141;   class ORD
\Gamma $\Gamma$ &#x0393;   class ORD
uppercase Greek letter gamma

see also:   \varGamma
\gamma $\gamma$ &#x03B3;   class ORD
lowercase Greek letter gamma
\gcd $\gcd$ class OP
greatest common divisor;
does not change size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples

Examples:
\gcd_{\rm sub}^{\rm sup}yields (inline mode)$\gcd_{\rm sub}^{\rm sup}$
\gcd_{\rm sub}^{\rm sup}yields (display mode)$\displaystyle\gcd_{\rm sub}^{\rm sup}$
\ge 
\geq 
\geqqAMSsymbols
\geqslantAMSsymbols
$\ge$
$\geq$
$\geqq$
$\geqslant$
&#x2265;   \ge
&#x2265;   \geq
&#x2267;   \geqq
&#x2A7E;   \geqslant
all class REL
greater than or equal to

see also:   \ngeq,   \ngeqq,   \ngeqslant
\genfracAMSmath
  the most general command for defining fractions with optional delimiters, line thickness, and specified style
\genfrac #1 #2 #3 #4 #5 #6
where:
  • #1 is the left delimiter (empty, for no left delimiter)
  • #2 is the right delimiter (empty, for no right delimiter)
  • #3 is the fraction bar thickness (set to 0pt to make it disappear)
  • #4 is either 0, 1, 2, or 3, where:
    • 0 denotes \displaystyle
    • 1 denotes \textstyle
    • 2 denotes \scriptstyle
    • 3 denotes \scriptscriptstyle
  • #5 is the numerator
  • #6 is the denominator
Example:
\genfrac(]{0pt}{2}{a+b}{c+d}yields $\genfrac(]{0pt}{2}{a+b}{c+d}$

see also:     \above,   \abovewithdelims,   \atop,   \atopwithdelims,
  \cfrac,   \dfrac,   \frac,   \over,   \overwithdelims
\gets $\gets$ &#x2190;   class REL
left arrow;
non-stretchy
\gg $\gg$ &#x226B;   class REL
\gggAMSsymbols
\gggtrAMSsymbols
$\ggg$
$\gggtr$
&#x22D9;class REL
&#x22D9;class REL
\gimelAMSsymbols
$\gimel$ &#x2137;   class ORD
Hebrew letter gimel
\gtrapproxAMSsymbols
\gnapproxAMSsymbols
$\gtrapprox$
$\gnapprox$
&#x2A86;class REL
&#x2A8A;class REL
\gneqAMSsymbols
\gneqqAMSsymbols
\gvertneqqAMSsymbols
$\gneq$
$\gneqq$
$\gvertneqq$
&#x2A88;class REL
&#x2269;class REL
&#x2269;class REL
\gtrsimAMSsymbols
\gnsimAMSsymbols
$\gtrsim$
$\gnsim$
&#x2273;class REL
&#x22E7;class REL
\grave $\grave{}$ &#x02CB;
grave accent
\grave #1
Usually, #1 is a single letter;  otherwise, accent is centered over argument.

Examples:
\grave e yields $\grave e$
\grave E yields $\grave E$
\grave eu yields $\grave eu$
\grave{eu} yields $\grave{eu}$
\gt $\gt$ &#x003E;   class REL
greater than

see also:   \ngtr
\gtrdotAMSsymbols
$\gtrdot$ &#x22D7;   class REL
\gtreqlessAMSsymbols
\gtreqqlessAMSsymbols
$\gtreqless$
$\gtreqqless$
&#x22DB;class REL
&#x2A8C;class REL
\gtrlessAMSsymbols
$\gtrless$ &#x2277;   class REL
H
\hat $\hat{}$ &#x02CA;
non-stretchy hat accent
\hat #1
Usually, #1 is a single letter;  otherwise, accent is centered over argument.

Examples:
\hat\imath yields $\hat\imath$
\hat\jmath yields $\hat\jmath$
\hat ab yields $\hat ab$
\hat{ab} yields $\hat{ab}$

see also:   \widehat
\hbar $\hbar$ &#x210F;   class ORD
Planck's constant
\hbox   class ORD
horizontal box;
contents are treated as text, but you can switch to math mode inside;
text appears in  \rm 
\hbox #1
Examples:

\hbox{\alpha a }\alpha a yields $\hbox{\alpha a }\alpha a$
\hbox{This is a sentence.} yields $\hbox{This is a sentence.}$
\hbox{for all $x > 0$} yields $\hbox{for all $x > 0$}$

in MathJax, these are essentially the same:   \text,   \mbox
see also:   \rm
\hdashline
\hline
  works in many of the environments to create a horizontal line (\hline), or a horizontal dashed line (\hdashline)

Putting   \hdashline   or   \hline   first or last encases the entire structure
(which is different from standard $\,\rm\LaTeX\,$ behavior):
\begin{matrix}
\hdashline
x_{11} & x_{12} \\
x_{21} & x_{22} \\
x_{31} & x_{32}
\end{matrix}
yields $ \begin{matrix} \hdashline x_{11} & x_{12} \\ x_{21} & x_{22} \\ x_{31} & x_{32} \end{matrix} $
\begin{matrix}
x_{11} & x_{12} \\
x_{21} & x_{22} \\
x_{31} & x_{32} \\
\hline
\end{matrix}
yields $ \begin{matrix} x_{11} & x_{12} \\ x_{21} & x_{22} \\ x_{31} & x_{32} \\ \hline \end{matrix} $
Putting   \hdashline   or   \hline   at the beginning of any subsequent row puts a line over that row:
\begin{matrix}
x_{11} & x_{12} \\
x_{21} & x_{22} \\
\hline
x_{31} & x_{32}
\end{matrix}
yields $ \begin{matrix} x_{11} & x_{12} \\ x_{21} & x_{22} \\ \hline x_{31} & x_{32} \end{matrix} $
You can combine effects, and put in struts (as desired) for additional vertical spacing:
\begin{matrix}
\hline
x_{11} & x_{12} \\
x_{21} & x_{22} \strut \\
\hdashline
x_{31} & x_{32} \strut
\end{matrix}
yields $ \begin{matrix} \hline x_{11} & x_{12} \\ x_{21} & x_{22} \strut \\ \hdashline x_{31} & x_{32} \strut \end{matrix} $
\heartsuit $\heartsuit$ &#x2661;   class ORD

see also:   \clubsuit,   \diamondsuit,   \spadesuit
\hom $\hom$ class OP
homomorphism;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples
\hookleftarrow
\hookrightarrow
$\hookleftarrow$
$\hookrightarrow$
&#x21A9;non-stretchy
&#x21AA;non-stretchy
both class REL
\hphantom   class ORD
horizontal phantom

Sometimes you want to pretend that something is there, for spacing reasons,
but you don't want it to appear—you want it to be invisible—you want it to be a phantom.

The box created by   \hphantom   has the width of its argument,
but its height and depth are zero (so it doesn't contribute to any vertical spacing issues).
In other words, \hphantom   creates horizontal space equal to that produced by its argument,
but doesn't create any vertical space.
\hphantom #1
Example:
\begin{array}{l}
\text{Side Angle Side}\\
\text{S}\hphantom{\text{ide }}\text{A}\hphantom{\text{ngle }}\text{S}
\end{array}
yields

$ \begin{array}{l} \text{Side Angle Side}\\ \text{S}\hphantom{\text{ide }}\text{A}\hphantom{\text{ngle }}\text{S} \end{array} $

see also:   \phantom,   \vphantom
\href   used to make a math object into a link
\href{ <url> } #1
where the argument (#1) is the clickable area

Example:
\href{http://www.onemathematicalcat.org}{M^{A^{T^H}}} yields $\href{http://www.onemathematicalcat.org}{M^{A^{T^H}}}$
\hskip   horizontal glue; horizontal space; horizontal skipping;
\hskip <dimen>
Example:
w\hskip1em i\hskip2em d\hskip3em e\hskip4em r
yields

$ w\hskip1em i\hskip2em d\hskip3em e\hskip4em r $

in MathJax, these all behave the same:   \hspace,   \kern,   \mkern,   \mskip,   \mspace
\hslashAMSsymbols
$\hslash$ &#x210F;   class ORD
perhaps an alternative form of Planck's constant
\hspace   horizontal glue; horizontal space; horizontal skipping
\hspace <dimen>
Example:
s\hspace7ex k\hspace6ex i\hspace5ex n\hspace4ex n\hspace3ex i\hspace2ex e\hspace1ex r
yields

$ s\hspace7ex k\hspace6ex i\hspace5ex n\hspace4ex n\hspace3ex i\hspace2ex e\hspace1ex r $

in MathJax, these all behave the same:   \hskip,   \kern,   \mkern,   \mskip,   \mspace
\Huge
\huge
  both class ORD
turns on huge mode and an even bigger Huge mode
{\Huge ... }
{\huge ... }
Examples:
\huge AaBb\alpha\beta123\frac ab\sqrt x yields $\huge AaBb\alpha\beta123\frac ab\sqrt x$
{\huge A B} A B yields ${\huge A B} A B$
A\alpha\huge A\alpha \Huge A\alpha yields $A\alpha\huge A\alpha \Huge A\alpha$
see also:   \LARGE, \Large, \large
I
\iddots $\def\iddots{{\kern3mu\raise1mu{.}\kern3mu\raise6mu{.}\kern3mu \raise12mu{.}}}\iddots$

Not in MathJax Library
inner diagonal dots;

This macro must be supplied by the user, if desired.
Davide Cervone provided the code (given here) in the MathJax User Group.

To use this macro, put the following definition in either inline or display mathematics:
$
\def\iddots{
  {\kern3mu\raise1mu{.}\kern3mu\raise6mu{.}\kern3mu\raise12mu{.}}}
$ 
Then, in any subsequent mathematics:

\iddots yields $\iddots$
Instead of providing the definition inside math delimiters in the body,
you can add the definition to your configuration using the  Macros  property of the  TeX  block:
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
TeX: {
Macros: {
  iddots: "{\\kern3mu\\raise1mu{.}\\kern3mu\\raise6mu{.}\\kern3mu\\raise12mu{.}}"
}}});
</script>
\idotsintAMSmath
$\idotsint$ class OP
changes size;
can change limit placement using \limits;
see the Big Operators Table for examples
\iff $\iff$ &#x27FA;   with a thick space on both sides
if and only if;   is equivalent to;
non-stretchy

Example:
A\iff B   yields   $A\iff B$
\iiiintAMSmath
\iiint 
\iint 
\int 
$\iiiint$
$\iiint$
$\iint$
$\int$
four occurrences of &#x222B; 
&#x222D;
&#x222C;
&#x222B;
all class OP;
see the Big Operators Table for examples

Compare the different limit placements (both in display mode):
\int_a^byields$$\int_a^b$$
\intop_a^byields$$\intop_a^b$$
see also:   \intop
\intop 
$\intop$
&#x222B; (with movable limits)   class OP

See the Big Operators Table for examples.

see also:   \iiiint, \iiint, \iint, \int
\Im $\Im$ &#x2111;   class ORD
\imath $\imath$ &#x0131;   class ORD

a dotless ‘i’;
better to use when accented

Examples:
\hat i yields $\hat i$
\hat\imath yields $\hat\imath$

see also:   \jmath
\impliedbyAMSsymbols
$\impliedby$ &#x27F8;   with a thick space on both sides
non-stretchy

Example:
P\impliedby Q   yields   $P\impliedby Q$
\impliesAMSsymbols
$\implies$ &#x27F9;   with a thick space on both sides
non-stretchy

Example:
P\implies Q   yields   $P\implies Q$
\in $\in$ &#x2208;   class REL
is in;   is an element of;   indicates membership in a set;

see also:   \ni,   \notin,   \owns
\inf $\inf$ class OP
infimum;   least upper bound;
does not change size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples

Examples:
\inf_{\rm limit}yields (inline mode)$\inf_{\rm limit}$
\inf_{\rm limit}yields (display mode)$\displaystyle\inf_{\rm limit}$
see also:   \sup
\infty $\infty$ &#x221E;   class ORD
infinity
\injlimAMSmath
$\injlim$ class OP
injective limit;
does not change size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples

see also:   \varinjlim
\intercalAMSsymbols
$\intercal$ &#x22BA;   class BIN
\iota $\iota$ &#x03B9;   class ORD
lowercase Greek letter iota
\it   class ORD
turns on math italic mode;
to return to math italic mode if it had been turned off
{\it ... }
Examples:
{\bf ab \it ab} ab yields ${\bf ab \it ab} ab$
\rm for\ all\ {\it x}\ in\ \Bbb R yields $\rm for\ all\ {\it x}\ in\ \Bbb R$
\Delta\Gamma\Lambda{\it \Delta\Gamma\Lambda} yields $\Delta\Gamma\Lambda{\it \Delta\Gamma\Lambda}$

see also:   \mathit,   \mit
J
\jmath $\jmath$ &#x0237;   class ORD
a dotless ‘j’;
better to use when accented

Examples:
\hat j yields $\hat j$
\hat\jmath yields $\hat\jmath$

see also:   \imath
\JoinAMSsymbols
$\Join$ &#x22C8;   class REL
K
\kappa $\kappa$ &#x03BA;   class ORD
lowercase Greek letter kappa

see also:   \varkappa
\ker $\ker$ class OP
kernel;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples
\kern   to get a specified amount of horizontal space;
a negative argument forces ‘backing up’, so items can overlap
\kern <dimen>
Examples:
|\kern 2ex|\kern 2em|\kern 2pt| yields $|\kern 2ex|\kern 2em|\kern 2pt|$
\rm I\kern-2.5pt R yields $\rm I\kern-2.5pt R$
in MathJax, these all behave the same:   \hskip,   \hspace,   \mkern,   \mskip,   \mspace
L
\Lambda
\lambda
$\Lambda$
$\lambda$
uppercase Greek letter lambda &#x039B;   class ORD
lowercase Greek letter lambda &#x03BB;   class ORD
see also:   \varLambda
\land $\land$
logical AND &#x2227;   class BIN
see also:   \lor,   \wedge
\langle $\langle$
left angle bracket;
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below)
&#x27E8;   class OPEN

Example:
\left\langle
\matrix{a & b\cr c & d}
\right\rangle
yields $\left\langle \matrix{a & b\cr c & d} \right\rangle$
see also:   \rangle
\LARGE
\Large
\large
 
turns on large typestyles; affects all math all class ORD
{\LARGE ... }
{\Large ... }
{\large ... }
Examples:
\Large AaBb\alpha\beta123\frac ab yields $\Large AaBb\alpha\beta123\frac ab$
{\Large A B} A B yields ${\Large A B} A B$
AB \large AB \Large AB \LARGE AB yields $AB \large AB \Large AB \LARGE AB$
\Large{AB}CD yields $\Large{AB}CD$
see also:   \huge, \Huge
\LaTeX $\LaTeX$
the LaTeX logo class ORD

Example:
\rm\LaTeX   yields   $\rm\LaTeX$

see also:   \TeX
\lbrace $\lbrace$
left brace:
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below)
class OPEN

Examples:

\lbrace \frac ab, c \rbrace yields $\lbrace \frac ab, c \rbrace$
\left\lbrace \frac ab, c \right\rbrace yields $\left\lbrace \frac ab, c \right\rbrace$
see also:   \rbrace,   \{ \}
\lbrack $\lbrack$
left bracket:
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below);
class OPEN

Examples:

\lbrack \frac ab, c \rbrack yields $\lbrack \frac ab, c \rbrack$
\left\lbrack \frac ab, c \right\rbrack yields $\left\lbrack \frac ab, c \right\rbrack$
see also:   \rbrack,   [ ]
\lceil $\lceil$
left ceiling;
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below)
&#x2308;   class OPEN

Example:
\left\lceil
\matrix{a & b\cr c & d}
\right\rceil
yields $\left\lceil \matrix{a & b\cr c & d} \right\rceil$
see also:   \rceil,   \lfloor,   \rfloor
\ldotp $\ldotp$
lower dot, punctuation symbol &#x002E;   class PUNCT

Examples:
\rm s \ldotp h yields $\rm s \ldotp h$
\rm s.h yields $\rm s.h$
see also:   \cdotp
\ldots $\ldots$
lower dots;   ellipsis;   ellipses;   dot dot dot &#x2026;   class INNER

Example:
x_1,\ldots,x_n   yields   $x_1,\ldots,x_n$

see also:   \cdots,   \dots
\le 
\leq 
\leqqAMSsymbols
\leqslantAMSsymbols
$\le$
$\leq$
$\leqq$
$\leqslant$
less than or equal to&#x2264;   class REL
less than or equal to&#x2264;   class REL
less than or equal to&#x2266;   class REL
less than or equal to&#x2A7D;   class REL

see also:   \nleq,   \nleqq,   \nleqslant
\leadstoAMSsymbols
$\leadsto$
&#x21DD;   class REL
\left    used for stretchy delimiters;
see the Variable-Sized Delimiters Table for details

Examples:
\left( \frac12 \right) yields $\left( \frac12 \right)$
\left\updownarrow \phantom{\frac12} \right\Updownarrow yields $\left\updownarrow \phantom{\frac12} \right\Updownarrow$

see also:   \right
\leftarrow
\Leftarrow
$\leftarrow$
$\Leftarrow$
left arrow; non-stretchy &#x2190;   class REL
left arrow; non-stretchy &#x21D0;   class REL

see also:   \nleftarrow,   \nLeftarrow
\leftarrowtailAMSsymbols
$\leftarrowtail$
left arrow tail; non-stretchy &#x21A2;   class REL

see also:   \rightarrowtail
\leftharpoondown
\leftharpoonup
$\leftharpoondown$
$\leftharpoonup$
left harpoon arrow; non-stretchy &#x21BD;   class REL
left harpoon arrow; non-stretchy &#x21BC;   class REL
\leftleftarrowsAMSsymbols
$\leftleftarrows$
left left arrows; non-stretchy &#x21C7;   class REL
\leftrightarrow
\Leftrightarrow
$\leftrightarrow$
$\Leftrightarrow$
left right arrow; non-stretchy &#x2194;   class REL
left right arrow; non-stretchy &#x21D4;   class REL

see also:   \nleftrightarrow,   \nLeftrightarrow
\leftrightarrowsAMSsymbols
$\leftrightarrows$
left right arrows; non-stretchy &#x21C6;   class REL
\leftrightharpoonsAMSsymbols
$\leftrightharpoons$
left right harpoons; non-stretchy &#x21CB;   class REL
\leftrightsquigarrowAMSsymbols
$\leftrightsquigarrow$
left right squiqqle arrow; non-stretchy &#x21AD;   class REL
\leftroot   used to fine-tune the placement of the index inside   \sqrt   or   \root   (see examples)
\sqrt[... \leftroot #1 ...]{...}
\root ... \leftroot #1 ... \of {...}
where the argument is a small integer:
a positive integer moves the index to the left;
a negative integer moves the index to the right

Examples:
\sqrt[3]{x} yields $\sqrt[3]{x}$
\sqrt[3\leftroot1]{x} yields $\sqrt[3\leftroot1]{x}$
\root 3 \of x yields $\root 3 \of x$
\root 3\leftroot{-1} \of x yields $\root 3\leftroot{-1} \of x$
\root 3\leftroot{-1}\uproot2 \of x yields $\root 3\leftroot{-1}\uproot2 \of x$

see also:   \uproot,   \root
\leftthreetimesAMSsymbols
$\leftthreetimes$
&#x22CB;   class BIN
\leqalignno   equation alignment with optionally numbered (tagged) lines;
in $\rm\TeX$,  \leqalignno  puts the tags on the left, but MathJax doesn't implement this behavior;
currently, tags appear in a column on the right separated from the equations by a fixed amount of space (so they don't work like tags in the AMS math environments);
this may be fixed in a future version of MathJax
\leqalignno{ <math> & <math> & <equation tag> \cr <repeat as needed> }
the first ampersand is placed where alignment is desired;
the second ampersand is used just before a tag;
if there is no tag, then the final   & <equation tag>   is omitted;
a double-backslash can be used in place of the  \cr ;
the final   \\   or   \cr   is optional;
output is the same in both inline and display modes
(except for the amount of vertical space before and after);


Example:
\leqalignno{
3x - 4y &= 5   &(\dagger) \cr
x  +  7 &= -2y &(\ddagger)\cr
      z &= 2
}
yields: $$ \leqalignno{ 3x - 4y &= 5 &(\dagger) \cr x + 7 &= -2y &(\ddagger)\cr z &= 2 } $$ see also:   \eqalignno;   the align environment
\lessapproxAMSsymbols
$\lessapprox$
see also:   \lnapprox &#x2A85;   class REL

\lessdotAMSsymbols
$\lessdot$
&#x22D6;   class REL
\lesseqgtrAMSsymbols
\lesseqqgtrAMSsymbols
$\lesseqgtr$
$\lesseqqgtr$
&#x22DA;   class REL
&#x2A8B;   class REL
\lessgtrAMSsymbols
$\lessgtr$
&#x2276;   class REL
\lesssimAMSsymbols
$\lesssim$
see also:   \lnsim &#x2272;   class REL
\lfloor $\lfloor$
left floor;
non-stretchy when used alone;
stretchy when used with   \left   or   \right
&#x230A;   class OPEN

see also:   \rfloor,   \lceil,   \rceil
\lg $\lg$
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples
class OP
\lgroup $\lgroup$
left group;
non-stretchy when used alone;
stretchy when used with   \left   or   \right
&#x27EE;   class OPEN

Example:
\left\lgroup
\matrix{a & b\cr c & d}
\right\rgroup
yields $\left\lgroup \matrix{a & b\cr c & d} \right\rgroup$
see also:   \rgroup
\lhdAMSsymbols
$\lhd$
left-hand diamond &#x22B2;   class REL

see also:   \rhd
\lim $\lim$
limit;
does not change size;
can change limit placement using  \limits  and  \nolimits;
see the Big Operators Table for examples
class OP

Examples:
\lim_{n\rightarrow\infty} f(x) = \ell   (inline mode) yields $\lim_{n\rightarrow\infty} f(x) = \ell$
\lim_{n\rightarrow\infty} f(x) = \ell   (display mode) yields $$\lim_{n\rightarrow\infty} f(x) = \ell$$
\liminf $\liminf$
limit inferior;
does not change size;
can change limit placement using  \limits  and  \nolimits;
see the Big Operators Table for examples
class OP

Examples:
\liminf_{n\rightarrow\infty} x_n = \ell   (inline mode) yields $\liminf_{n\rightarrow\infty} x_n = \ell$
\liminf_{n\rightarrow\infty}\ x_n = \ell   (display mode) yields $$\liminf_{n\rightarrow\infty}\ x_n = \ell$$
see also:   \varliminf
\limits   used to set limits above/below any token of class OP;
see the Big Operators table for more information and examples

Examples:

\int_a^b f(x)\,dx   (inline mode) yields $\int_a^b f(x)\,dx$
\int\limits_a^b f(x)\,dx   (inline mode) yields $\int\limits_a^b f(x)\,dx$
\int_a^b f(x)\,dx   (display mode) yields $$\int_a^b f(x)\,dx$$
\int\limits_a^b f(x)\,dx   (display mode) yields $$\int\limits_a^b f(x)\,dx$$
\mathop{x}\limits_0^1 yields $\mathop{x}\limits_0^1$
see also:   \nolimits
\limsup $\limsup$
limit superior;
does not change size;
can change limit placement using  \limits  and  \nolimits;
see the Big Operators Table for examples
class OP

Examples:
\limsup_{n\rightarrow\infty} x_n   (inline mode) yields $\limsup_{n\rightarrow\infty} x_n$
\limsup_{n\rightarrow\infty}\ x_n   (display mode) yields $$\limsup_{n\rightarrow\infty}\ x_n$$
see also:   \varlimsup
\ll $\ll$
&x226A;   class REL
\llap  
left overlap class ORD
\llap #1
creates a box of width zero;
the argument is then placed just to the left of this zero-width box
(and hence will overlap whatever lies to the left);
proper use of  \llap  and  \rlap  in math expressions is somewhat delicate

Examples:

a\mathrel{{=}\llap{/}}b yields $a\mathrel{{=}\llap{/}}b$ {=} forces the equal to not have REL spacing (since it is not adjacent to ORD's) and \mathrel{} forces the compound symbol (equal with overlapping slash) to be treated as a single REL
a\mathrel{{=}\llap{/\,}}b yields $a\mathrel{{=}\llap{/\,}}b$ the thinspace ‘\,’ improves the spacing
a=\mathrel{\llap{/\,}}b yields $a=\mathrel{\llap{/\,}}b$ this works because the spacing between adjacent REL's is zero
see also:   \rlap
\llcornerAMSsymbols
\lrcornerAMSsymbols
$\llcorner$
$\lrcorner$
lower left corner&#x2514;   class REL
lower right corner&#x2518;   class REL
These are technically delimiters, but MathJax doesn't stretch them like it should.

see also:   \ulcorner,   \urcorner
\LleftarrowAMSsymbols
$\Lleftarrow$
non-stretchy &#x21DA;   class REL
\lllAMSsymbols
\lllessAMSsymbols
$\lll$
$\llless$
  &#x22D8;   class REL
  &#x22D8;   class REL
\lmoustache $\lmoustache$
left moustache;
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below)
&#x23B0;   class OPEN

Example:
\left\lmoustache
\phantom{\matrix{a & b\cr c & d}}
\right\rmoustache
yields $$ \left\lmoustache \phantom{\matrix{a & b\cr c & d}} \right\rmoustache $$
see also:   \rmoustache
\ln $\ln$
natural logarithm;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples
class OP
\lnapproxAMSsymbols
$\lnapprox$
see also:   \lessapprox &#x2A89;   class REL

\lneqAMSsymbols
\lneqqAMSsymbols
$\lneq$
$\lneqq$
see also:   \leq&#x2A87;   class REL
see also:   \leqq &#x2268;   class REL

\lnot $\lnot$
logical not &#x00AC;   class ORD

see also:   \neg
\lnsimAMSsymbols
$\lnsim$
see also:   \lesssim &#x22E6;   class REL

\log $\log$
logarithm;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for examples
class OP
\longleftarrow
\Longleftarrow
\longrightarrow
\Longrightarrow
$\longleftarrow$
$\Longleftarrow$
$\longrightarrow$
$\Longrightarrow$
non-stretchy&#x27F5;   class REL
non-stretchy&#x27F8;   class REL
non-stretchy&#x27F6;   class REL
non-stretchy&#x27F9;   class REL
\longleftrightarrow
\Longleftrightarrow
$\longleftrightarrow$
$\Longleftrightarrow$
non-stretchy &#x27F7;   class REL
non-stretchy &#x27FA;   class REL
\longmapsto $\longmapsto$
long maps to &#x27FC;   class REL

see also:   \mapsto
\looparrowleftAMSsymbols
\looparrowrightAMSsymbols
$\looparrowleft$
$\looparrowright$
non-stretchy &#x21AB;   class REL
non-stretchy &#x21AC;   class REL
\lor $\lor$
logical OR &#x2228;   class BIN

see also:   \land,   \vee
\lower  
\lower <dimen> #1
lowers the argument by the amount specified in <dimen>;
in actual $\rm\TeX$, the argument to  \lower  (and  \raise ) must be an  \hbox ,
but in MathJax it can be any expression (using an \hbox is allowed, but not required)

Example:
l\lower 2pt {owe} r yields $l\lower 2pt {owe} r$
see also:   \raise
\lozengeAMSsymbols
$\lozenge$
&#x25CA;   class ORD
\LshAMSsymbols
$\Lsh$
left shift; non-stretchy &#x21B0;   class REL

see also:   \Rsh
\lt $\lt$
less than &#x003C;   class REL

see also:   \nless
\ltimesAMSsymbols
$\ltimes$
see also:   \rtimes &#x22C9;   class BIN

\lvertAMSmath
\lVertAMSmath
$\lvert$
$\lVert$
both non-stretchy when used alone;&#x2223;   class OPEN
stretchy when used with   \left   or   \right &#x2225;   class OPEN

Example:
\left\lvert\frac{\frac ab}{\frac cd}\right\rvert yields $\left\lvert\frac{\frac ab}{\frac cd}\right\rvert$
see also:   \rvert,   \rVert,   |,   \|
\lvertneqqAMSsymbols
$\lvertneqq$
&#x2268;   class REL
M
\malteseAMSsymbols
$\maltese$
&#x2720;   class ORD
\mapsto $\mapsto$
maps to; non-stretchy math operator &#x21A6;   class REL

see also:   \longmapsto
\mathbb  
blackboard-bold for uppercase letters and lowercase ‘k’;
if lowercase blackboard-bold letters are not available, then they are typeset in a roman font
class ORD
\mathbb #1
Whether lower-case letters are displayed in blackboard-bold, or not, depends on the fonts being used.
The MathJax web-based fonts don't have lowercase blackboard-bold, but the STIX fonts do;
so users with the STIX fonts installed will be able to display lowercase blackboard-bold letters.

Examples:
\mathbb R yields $\mathbb R$
\mathbb ZR yields $\mathbb ZR$
\mathbb{AaBbKk}Cc yields $\mathbb{AaBbKk}Cc$
\mathbb{ABCDEFGHIJKLMNOPQRSTUVWXYZ} yields $\mathbb{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$

see also:   \Bbb
\mathbf  
boldface for uppercase and lowercase letters and digits class ORD
\mathbf #1
Examples:
\mathbf{AaBb\alpha\beta123} yields $\mathbf{AaBb\alpha\beta123}$
\mathbf ZR yields $\mathbf ZR$
\mathbf{uvw}xyz yields $\mathbf{uvw}xyz$

see also:   \bf,   \boldsymbol
\mathbin  
gives the correct spacing to make an object into a binary operator;
binary operators have some extra space around them;
creates an element of class BIN
class BIN
\mathbin #1
Examples:
a\text{op} b yields $a\text{op} b$
a\mathbin{\text{op}} b yields $a\mathbin{\text{op}} b$
a\Diamond b yields $a\Diamond b$
a\mathbin{\Diamond}b yields $a\mathbin{\Diamond} b$
\mathcal  
calligraphic font for uppercase letters and digits class ORD
\mathcal #1
Examples:
\mathcal{ABCDEFGHIJKLMNOPQRSTUVWXYZ} yields $\mathcal{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
\mathcal{0123456789} yields $\mathcal{0123456789}$
\mathcal{abcdefghijklmnopqrstuvwxyz} yields $\mathcal{abcdefghijklmnopqrstuvwxyz}$
abcdefghijklmnopqrstuvwxyz yields $abcdefghijklmnopqrstuvwxyz$
\mathcal{AB}AB yields $\mathcal{AB}AB$

see also:   \cal,   \oldstyle
\mathchoice   provides content that is dependent on the current style (display, text, script, or scriptscript);
can be used in defining a macro for general use
\mathchoice #1 #2 #3 #4
where:
  • #1 is rendered when the  \mathchoice  appears in display style
  • #2 is rendered when the  \mathchoice  appears in text style
  • #3 is rendered when the  \mathchoice  appears in script style
  • #4 is rendered when the  \mathchoice  appears in scriptscript style
Examples:
\mathchoice{D}{T}{S}{SS}   (in display style) yields $$\mathchoice{D}{T}{S}{SS}$$
\mathchoice{D}{T}{S}{SS}   (in text style) yields $\mathchoice{D}{T}{S}{SS}$
\mathchoice{D}{T}{S}{SS}   (in script style) yields $\scriptstyle\mathchoice{D}{T}{S}{SS}$
\mathchoice{D}{T}{S}{SS}   (in scriptscript style) yields $\scriptscriptstyle\mathchoice{D}{T}{S}{SS}$
Here's a nice example from the $\rm\TeX$Book:
Define:
\def\puzzle{\mathchoice{D}{T}{S}{SS}}
Then:
\puzzle{\puzzle\over\puzzle^{\puzzle^\puzzle}} yields (in display mode) $$\def\puzzle{\mathchoice{D}{T}{S}{SS}} \puzzle{\puzzle\over\puzzle^{\puzzle^\puzzle}} $$
\puzzle{\puzzle\over\puzzle^{\puzzle^\puzzle}} yields (in inline mode) $\puzzle{\puzzle\over\puzzle^{\puzzle^\puzzle}}$
\mathclose  
forces the argument to be treated in the ‘closing’ class;   for example, like ‘$)$’ and ‘$]$’;
creates an element of class CLOSE
class CLOSE
\mathclose #1
Examples:
a + \lt b\gt + c yields $a + \lt b\gt + c$
a + \mathopen\lt b\mathclose\gt + c yields $a + \mathopen\lt b\mathclose\gt + c$

see also:   \mathopen
\mathfrak  
fraktur font for uppercase and lowercase letters and digits (and a few other characters) class ORD
\mathfrak #1
Examples:
\mathfrak{ABCDEFGHIJKLMNOPQRSTUVWXYZ} yields $\mathfrak{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
\mathfrak{0123456789} yields $\mathfrak{0123456789}$
\mathfrak{abcdefghijklmnopqrstuvwxyz} yields $\mathfrak{abcdefghijklmnopqrstuvwxyz}$
\mathfrak{AB}AB yields $\mathfrak{AB}AB$

see also:   \frak
\mathinner  
some constructions are meant to appear ‘inside’ other formulas,
and should be surrounded by additional space in certain circumstances;
this classification is forced on the argument by using \mathinner
class INNER
\mathinner #1
Examples:
ab\text{inside}cd yields $ab\text{inside}cd$
ab\mathinner{\text{inside}}cd yields $ab\mathinner{\text{inside}}cd$
\mathit  
math italic mode class ORD
\mathit #1
Examples:
\rm abc \mathit{def} ghi yields $\rm abc \mathit{def} ghi$

in MathJax, this is the same as:   \mit   and   \it
\mathop  
forces the argument to be treated in the ‘large operator’ class;   for example, like ‘$\sum$’;
creates an element of class OP
class OP
\mathop #1
Examples:
atbtc yields $atbtc$
a\mathop{t}b\mathop{t}c yields $a\mathop{t}b\mathop{t}c$
\star_a^b yields (in display mode) $$\star_a^b$$
\mathop{\star}_a^b yields (in display mode) $$\mathop{\star}_a^b$$
\mathopen  
forces the argument to be treated in the ‘opening’ class;   for example, like ‘$($’ and ‘$[$’;
creates an element of class OPEN
class OPEN
\mathopen #1
Examples:
a + \lt b\gt + c yields $a + \lt b\gt + c$
a + \mathopen\lt b\mathclose\gt + c yields $a + \mathopen\lt b\mathclose\gt + c$

see also:   \mathclose
\mathord  
forces the argument to be treated in the ‘ordinary’ class;   for example, like ‘$/$’;
spacing is determined by pairs of tokens;
there is no extra spacing between adjacent ORD's (as in the second example below);
there is extra spacing between an  ORD  and a  BIN  (as in the first example below);
creates an element of class ORD
class ORD
\mathord #1
Examples:
a+b+c yields $a+b+c$
a\mathord{+}b\mathord{+}c yields $a\mathord{+}b\mathord{+}c$
1,234,567 yields $1,234,567$
1\mathord{,}234{,}567 yields $1\mathord{,}234{,}567$
\mathpunct  
forces the argument to be treated in the ‘punctuation’ class;   for example, like ‘$,$’;
punctuation tends to have some extra space after the symbol;
returns an element of class PUNCT
class PUNCT
\mathpunct #1
Examples:
1.234 yields $1.234$
1\mathpunct{.}234 yields $1\mathpunct{.}234$
\mathrel  
forces the argument to be treated in the ‘relation’ class;   for example, like ‘$=$’ and ‘$\gt$’;
relations have a bit more space on both sides than binary operators;
returns an element of class REL
class REL
\mathrel #1
Examples:
a \# b yields $ a \# b$
a \mathrel{\#} b yields $ a \mathrel{\#} b$
\mathringAMSmath
$\mathring{}$
&#x2DA;
\mathring #1
Examples:
\mathring A yields $\mathring A$
\mathring{AB}C yields $\mathring{AB}C$
\mathrm  
roman typestyle for uppercase and lowercase letters
class ORD
\mathrm #1
Examples:
\mathrm{AaBb\alpha\beta123} yields $\mathrm{AaBb\alpha\beta123}$
\mathrm ZR yields $\mathrm ZR$
\mathrm{uvw}xyz yields $\mathrm{uvw}xyz$

see also:   \rm
\mathscr  
script typestyle for uppercase letters;
if lowercase script letters are not available, then they are typeset in a roman typestyle
class ORD
\mathscr #1
Whether lower-case letters are displayed in script, or not, depends on the fonts being used.
The MathJax web-based fonts don't have lowercase script, but the STIX fonts do;
so users with the STIX fonts installed will be able to display lowercase script letters.

Examples:
\mathscr{ABCDEFGHIJKLMNOPQRSTUVWXYZ} yields $\mathscr{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
\mathscr{0123456789} yields $\mathscr{0123456789}$
\mathscr{abcdefghijklmnopqrstuvwxyz} yields $\mathscr{abcdefghijklmnopqrstuvwxyz}$
abcdefghijklmnopqrstuvwxyz yields $abcdefghijklmnopqrstuvwxyz$
\mathscr{AB}AB yields $\mathscr{AB}AB$

see also:   \scr
\mathsf  
sans serif typestyle for uppercase and lowercase letters and digits;
also affects uppercase greek (as do the other font switches,
like \rm, \it, \bf, \mathrm, \mathit, \mathbf, etc).
class ORD
\mathsf #1
Examples:
\mathsf{ABCDEFGHIJKLMNOPQRSTUVWXYZ} yields $\mathsf{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
\mathsf{0123456789} yields $\mathsf{0123456789}$
\mathsf{abcdefghijklmnopqrstuvwxyz} yields $\mathsf{abcdefghijklmnopqrstuvwxyz}$
\Delta\Gamma\Lambda\mathsf{\Delta\Gamma\Lambda} yields $\Delta\Gamma\Lambda\mathsf{\Delta\Gamma\Lambda}$
abcdefghijklmnopqrstuvwxyz yields $abcdefghijklmnopqrstuvwxyz$
\mathsf{AB}AB yields $\mathsf{AB}AB$

see also:   \sf
\mathstrut  
an invisible box whose width is zero;
its height and depth are the same as a parenthesis ‘$($’;
can be used to achieve more uniform appearance in adjacent formulas
class ORD

Examples:
\sqrt3 + \sqrt\alpha yields $\sqrt3 + \sqrt\alpha$
\sqrt{\mathstrut 3} + \sqrt{\mathstrut\alpha} yields $\sqrt{\mathstrut 3} + \sqrt{\mathstrut\alpha}$
\mathtt  
typewriter typestyle for uppercase and lowercase letters and digits;
also affects uppercase Greek
class ORD
\mathtt #1
Examples:
\mathtt{ABCDEFGHIJKLMNOPQRSTUVWXYZ} yields $\mathtt{ABCDEFGHIJKLMNOPQRSTUVWXYZ}$
\mathtt{0123456789} yields $\mathtt{0123456789}$
\mathtt{abcdefghijklmnopqrstuvwxyz} yields $\mathtt{abcdefghijklmnopqrstuvwxyz}$
abcdefghijklmnopqrstuvwxyz yields $abcdefghijklmnopqrstuvwxyz$
\Delta\Gamma\Lambda\mathtt{\Delta\Gamma\Lambda} yields $\Delta\Gamma\Lambda\mathtt{\Delta\Gamma\Lambda}$
\mathtt{AB}AB yields $\mathtt{AB}AB$

see also:   \sf
\matrix   matrix (without any delimiters)
\matrix{ <math> & <math> ... \cr <repeat as needed> }
alignment occurs at the ampersands;
a double-backslash can be used in place of the  \cr ;
the final   \\   or   \cr   is optional

Example:
\matrix{ a & b \cr c & d }
yields $ \matrix{ a & b \cr c & d } $

see also:   \array
\max $\max$
maximum;
does not change size;
can change limit placement using  \limits  and  \nolimits;
see the Big Operators Table for examples
class OP

Examples:
\max_{\rm sub}yields (inline mode)$\max_{\rm sub}$
\max_{\rm sub}yields (display mode)$\displaystyle\max_{\rm sub}$
see also:   \min
\mbox  
creates a box just wide enough to hold the text in its argument;
no linebreaks are allowed in the text;
text appears in  \rm 
class ORD
\mbox <text argument>

Examples:
a + b \mbox{ (are you paying attention?) } = c yields $a + b \mbox{ (are you paying attention?) } = c$
a + b \text{ (are you paying attention?) } = c yields $a + b \text{ (are you paying attention?) } = c$
in MathJax, these are essentially the same:   \text,   \hbox
see also:   \rm
\measuredangleAMSsymbols
$\measuredangle$
&#x2221;   class ORD
\mhoAMSsymbols
$\mho$
&#x2127;   class ORD
\mid $\mid$
the spacing is perfect for use in set-builder notation
&#x2223;   class REL

Examples:
\{x | x\gt 1\} yields $\{x | x\gt 1\}$
\{x \mid x\gt 1\} yields $\{x \mid x\gt 1\}$

see also:   \nmid,   \shortmid,   \nshortmid
\min $\min$
minimum;
does not change size;
can change limit placement using  \limits  and  \nolimits;
see the Big Operators Table for examples
class OP

Examples:
\min_{\rm sub}yields (inline mode)$\min_{\rm sub}$
\min_{\rm sub}yields (display mode)$\displaystyle\min_{\rm sub}$
see also:   \max
\mit  
math italic typestyle class ORD
\mit #1
Examples:
\mit{\Gamma\Delta\Theta\Omega} yields $\mit{\Gamma\Delta\Theta\Omega}$
\mathit{\Gamma\Delta\Theta\Omega} yields $\mathit{\Gamma\Delta\Theta\Omega}$
\Gamma\Delta\Theta\Omega yields $\Gamma\Delta\Theta\Omega$

in MathJax, this is the same as:   \mathit   and   \it
\mkern  
\mkern <dimen>
gives horizontal space

Examples:
ab yields $ab$
a\mkern18mu b yields $a\mkern18mu b$
a\mkern18pt b yields $a\mkern18pt b$
in MathJax, these all behave the same:   \hskip,   \hspace,   \kern,   \mskip,   \mspace
\mod $\mod{}$ modulus operator; modulo;
the leading space depends on the style:   displaystyle has 18 mu, others 12 mu;
2 thinspaces of following space;
for things like equations modulo a number
\mod #1
Example:
3\equiv 5 \mod 2 yields $3\equiv 5 \mod 2$
see also:   \pmod,   \bmod
\models $\models$
&#x22A8;   class REL
\moveleft
\moveright
  shifts boxes to the left or right
\moveleft <dimen> <box>
\moveright <dimen> <box>
In actual $\rm\TeX$, these require an  \hbox  (or some box) as an argument, and can only appear in vertical mode;
MathJax is less picky: you don't need an actual box, and MathJax doesn't have a vertical mode;
these are not really designed as user-level macros, but instead allow existing macros to work;
the box takes up its original space (unlike something like  \llap  or  \rlap ), but its contents are shifted (without affecting its bounding box)

Examples:
\rm tight yields $\rm tight$
\rm t\moveleft3pt ight yields $\rm t\moveleft3pt ight$
\rm t\moveleft3pt i\moveleft3pt g\moveleft3pt h\moveleft3pt t yields $\rm t\moveleft3pt i\moveleft3pt g\moveleft3pt h\moveleft3pt t$
\rm t\moveleft3pt i\moveleft6pt g\moveleft9pt h\moveleft12pt t yields $\rm t\moveleft3pt i\moveleft6pt g\moveleft9pt h\moveleft12pt t$
\square\square\moveleft 2em {\diamond\diamond} yields $\square\square\moveleft 2em {\diamond\diamond}$
\square\square\moveright 2em {\diamond\diamond} yields $\square\square\moveright 2em {\diamond\diamond}$
see also:   \raise,   \lower
\mp $\mp$
minus plus &#x2213;   class BIN

see also:   \pm
\mskip  
\mskip <dimen>
gives horizontal space

Examples:
ab yields $ab$
a\mskip18mu b yields $a\mskip18mu b$
a\mskip18pt b yields $a\mskip18pt b$
in MathJax, these all behave the same:   \hskip,   \hspace,   \kern,   \mkern,   \mspace
\mspace  
\mspace <dimen>
gives horizontal space

Examples:
ab yields $ab$
a\mspace18mu b yields $a\mspace18mu b$
a\mspace18pt b yields $a\mspace18pt b$
in MathJax, these all behave the same:   \hskip,   \hspace,   \kern,   \mkern,   \mskip
\mu $\mu$
lowercase Greek letter mu &#x03BC;   class ORD
\multimapAMSsymbols
$\multimap$
&#x22B8;   class REL
N
\nabla $\nabla$
&#x2207;   class ORD
\natural $\natural$
see also:   \flat,   \sharp &#x266E;   class ORD
\ncongAMSsymbols
$\ncong$
not congruent &#x2246;   class REL
see also:   \cong
\ne $\ne$
not equal &#x2260;   class REL
see also:   equals,   \neq
\nearrow $\nearrow$
northeast arrow; non-stretchy &#x2197;   class REL
see also:   \nwarrow,   \searrow,   \swarrow
\neg $\neg$
negate; negation &#x00AC;   class ORD
see also:   \lnot
\negthinspaceAMSmath
\negmedspaceAMSmath
\negthickspaceAMSmath
 
negative thin space
negative medium space
negative thick space

Examples:
ab yields $ab$
a\negthinspace b yields $a\negthinspace b$
a\negmedspace b yields $a\negmedspace b$
a\negthickspace b yields $a\negthickspace b$
see also:   \thinspace
\neq $\neq$
see also:   equals,   \ne &#x2260;   class REL
\newcommand   for defining your own commands (control sequences, macros, definitions);
\newcommand  must appear (within math delimiters) before it is used;
if desired, you can use the  TeX.Macros  property of the configuration to define macros in the head
\newcommand\myCommandName
  [ <optional # of arguments, from 1 to 9> ]
  { <replacement text> }
The bracketed # of arguments is omitted when there are no arguments.

Example (no arguments):
\newcommand\myHearts
  {\color{purple}{\heartsuit}\kern-2.5pt\color{green}{\heartsuit}}
  
\myHearts\myHearts
yields: $ \newcommand\myHearts {\color{purple}{\heartsuit}\kern-2.5pt\color{green}{\heartsuit}} \myHearts\myHearts $

A definition may take one or more arguments:

Example (two arguments):
\newcommand\myHearts[2]
  {\color{#1}{\heartsuit}\kern-2.5pt\color{#2}{\heartsuit}}
  
\myHearts{red}{blue}
yields: $ \newcommand\myHearts[2] {\color{#1}{\heartsuit}\kern-2.5pt\color{#2}{\heartsuit}} \myHearts{red}{blue} $

see also:   \def,   \newenvironment
\newenvironment   for defining your own environments;
\newenvironment  must appear (within math delimiters) before it is used
\newenvironment{myEnvironmentName}
  [ <optional # of arguments, from 1 to 9> ]
  { <replacement text for each occurrence of \begin{myEnvironmentName}> }
  { <replacement text for each occurrence of \end{myEnvironmentName}> }
The bracketed # of arguments is omitted when there are no arguments.
There must not be a command having the same name as the environment:
for example, to use   \begin{myHeart}...\end{myHeart}   there may not be a command \myHeart.

Example (no arguments):
\newenvironment{myHeartEnv}
  {\color{purple}{\heartsuit}\kern-2.5pt\color{green}{\heartsuit}}
  {\text{ forever}}
  
\begin{myHeartEnv}
\end{myHeartEnv}
yields: $ \newenvironment{myHeartEnv} {\color{purple}{\heartsuit}\kern-2.5pt\color{green}{\heartsuit}} {\text{ forever}} \begin{myHeartEnv} \end{myHeartEnv} $

An environment may take one or more arguments:

Example (two arguments):
\newenvironment{myHeartEnv}[2]
  {\color{#1}{\heartsuit}\kern-2.5pt\color{#2}{\heartsuit}}
  {\text{ forever}}
  
\begin{myHeartEnv}{red}{blue}
\end{myHeartEnv}
yields: $ \newenvironment{myHeartEnv}[2] {\color{#1}{\heartsuit}\kern-2.5pt\color{#2}{\heartsuit}} {\text{ forever}} \begin{myHeartEnv}{red}{blue} \end{myHeartEnv} $

see also:   \def,   \newcommand
\newline   line separator in alignment modes and environments

in MathJax, these are essentially the same:   \cr,   \\
\nexistsAMSsymbols
$\nexists$
see also:   \exists &#x2204;   class ORD
\ngeqAMSsymbols
\ngeqqAMSsymbols
$\ngeq$
$\ngeqq$
not greater than or equal to&#x2271;   class REL
not greater than or equal to&#x2271;   class REL
see also:   \geq,   \geqq
\ngeqslantAMSsymbols
$\ngeqslant$
slanted not greater than or equal to &#x2A88;   class REL
see also:   \geqslant
\ngtrAMSsymbols
$\ngtr$
not greater than &#x226F;   class REL
see also:   \gt
\ni $\ni$
backwards ‘in’; contains &#x220B;   class REL
see also:   \in
\nleftarrowAMSsymbols
\nLeftarrowAMSsymbols
$\nleftarrow$
$\nLeftarrow$
&#x219A;   class REL
&#x21CD;   class REL
see also:   \leftarrow,   \Leftarrow
\nleftrightarrowAMSsymbols
\nLeftrightarrowAMSsymbols
$\nleftrightarrow$
$\nLeftrightarrow$
&#x21AE;   class REL
&#x21CE;   class REL
see also:   \leftrightarrow,   \Leftrightarrow
\nleqAMSsymbols
\nleqqAMSsymbols
$\nleq$
$\nleqq$
not less than or equal to&#x2270;   class REL
not less than or equal to&#x2270;   class REL
see also:   \leq,   \leqq
\nleqslantAMSsymbols
$\nleqslant$
slanted not less than or equal to &#x2A87;   class REL
see also:   \leqslant
\nlessAMSsymbols
$\nless$
see also:   \lt &#x226E;   class REL
\nmidAMSsymbols
$\nmid$
see also:   \mid &#x2224;   class REL
\nobreakspaceAMSmath
 
Example: &#xA0;   class ORD
a\nobreakspace b yields $a\nobreakspace b$

in MathJax, this is the same as:   \  (backslash space)
\nolimits    used to change the default placement of limits;
only allowed on items of class  OP

Examples:
\sum_{k=1}^n a_k yields (in display mode) $$\sum_{k=1}^n a_k$$
\sum\nolimits_{k=1}^n a_k yields (in display mode) $$\sum\nolimits_{k=1}^n a_k$$
see also:   \limits
\normalsize  
turns on normal size class ORD
{\normalsize ... }
Example:
\rm \scriptsize script \normalsize normal \large large yields $\rm \scriptsize script \normalsize normal \large large $

see also:   \scriptsize
\not $\not{}$
used to negate relations &#x002F;   class REL
Examples:
\not\gt yields $\not\gt$
\ngtr yields $\ngtr$
\notagAMSmath
 
used in AMS math environments that do automatic equation numbering, to suppress the equation number; since MathJax doesn't implement auto-numbering (as of version 1.1a), it is basically a no-op, although it will cancel an explicit  \tag ;
when auto-numbering is added, then this will work as expected;
\notag  is included now for compatibility with existing TeX code (to prevent throwing an error, even though it has no effect)
class ORD
\notin $\notin$
see also:   \in &#x2209;   class REL
\nparallelAMSsymbols
$\nparallel$
not parallel &#x2226;   class REL
see also:   \parallel
\nprecAMSsymbols
$\nprec$
see also:   \prec &#x2280;   class REL
\npreceqAMSsymbols
$\npreceq$
see also:   \preceq &#x22E0;   class REL
\nrightarrowAMSsymbols
\nRightarrowAMSsymbols
$\nrightarrow$
$\nRightarrow$
&#x219B;   class REL
&#x21CF;   class REL
see also:   \rightarrow,   \Rightarrow
\nshortmidAMSsymbols
$\nshortmid$
see also:   \mid,   \shortmid &#x2224;   class REL
\nshortparallelAMSsymbols
$\nshortparallel$
see also:   \parallel,   \shortparallel &#x2226;   class REL
\nsimAMSsymbols
$\nsim$
see also:   \sim &#x2241;   class REL
\nsubseteqAMSsymbols
\nsubseteqqAMSsymbols
$\nsubseteq$
$\nsubseteqq$
&#x2288;   class REL
&#x2288;   class REL
see also:   \subseteq,   \subseteqq
\nsuccAMSsymbols
\nsucceqAMSsymbols
$\nsucc$
$\nsucceq$
&#x2281;   class REL
&#x22E1;   class REL
see also:   \succ,   \succeq
\nsupseteqAMSsymbols
\nsupseteqqAMSsymbols
$\nsupseteq$
$\nsupseteqq$
&#x2289;   class REL
&#x2289;   class REL
see also:   \supseteq,   \supseteqq
\ntriangleleftAMSsymbols
\ntrianglelefteqAMSsymbols
$\ntriangleleft$
$\ntrianglelefteq$
&#x22EA;   class REL
&#x22EC;   class REL
see also:   \triangleleft,   \trianglelefteq
\ntrianglerightAMSsymbols
\ntrianglerighteqAMSsymbols
$\ntriangleright$
$\ntrianglerighteq$
&#x22EB;   class REL
&#x22ED;   class REL
see also:   \triangleright,   \trianglerighteq
\nu $\nu$
lowercase Greek letter nu &#x03BD;   class ORD
\nVDashAMSsymbols
\nVdashAMSsymbols
\nvDashAMSsymbols
\nvdashAMSsymbols
$\nVDash$
$\nVdash$
$\nvDash$
$\nvdash$
&#x22AF;   class REL
&#x22AE;   class REL
&#x22AD;   class REL
&#x22AC;   class REL
see also:   \Vdash,   \vDash,   \vdash
\nwarrow $\nwarrow$
northwest arrow; non-stretchy &#x2196;   class REL
see also:   \nearrow,   \searrow,   \swarrow
O
\odot
\ominus
\oplus
\oslash
\otimes
$\odot$
$\ominus$
$\oplus$
$\oslash$
$\otimes$
&#x2299;   class BIN
&#x2296;   class BIN
&#x2295;   class BIN
&#x2298;   class BIN
&#x2297;   class BIN
\oint $\oint$
changes size;
can change limit placement using \limits;
see the Big Operators Table for examples
&#x222E;   class OP
\oldstyle  
this is intended for oldstyle numbers; it is a switch that turns on oldstyle mode;
the way it works in $\rm\TeX$ is to select the caligraphic font
(which is where the oldstyle numbers are stored),
so it has the side effect of selecting caligraphic upper-case letters;
MathJax does the same for compatibility
class ORD
{\oldstyle ... }
Examples:
\oldstyle 0123456789 yields $\oldstyle 0123456789$
\oldstyle ABCDEFGHIJKLMNOPQRSTUVWXYZ yields $\oldstyle ABCDEFGHIJKLMNOPQRSTUVWXYZ$
\oldstyle abcdefghijklmnopqrstuvwxyz yields $\oldstyle abcdefghijklmnopqrstuvwxyz$
abcdefghijklmnopqrstuvwxyz yields $abcdefghijklmnopqrstuvwxyz$
{\oldstyle AB}AB yields ${\oldstyle AB}AB$
\oldstyle AB \rm AB yields $\oldstyle AB \rm AB$
\oldstyle{AB}CD yields $\oldstyle{AB}CD$

see also:   \cal,   \mathcal
\omega
\Omega
$\omega$
$\Omega$
lowercase Greek letter omega&#x03C9;   class ORD
uppercase Greek letter omega&#x03A9;   class ORD
see also:   \varOmega
\omicron $\omicron$
lowercase Greek letter omicron &#x03BF;   class ORD
\operatornameAMSmath
 
This is similar to  \DeclareMathOperator,
but rather than defining a macro, it produces an instance of an operator like  \lim .

For example,
\operatorname{myOp}

is equivalent to the use of  \myOp , after having defined

\DeclareMathOperator{\myOp}{myOp}

If displaystyle limits are desired in both inline and display modes,
then use  operatorname*  instead of  operatorname
class OP

Examples:

\operatorname{myFct}(x) yields $\operatorname{myFct}(x)$
\operatorname*{myFct}_a^b(x) yields (in inline mode) $\operatorname*{myFct}_a^b(x)$
See  \DeclareMathOperator  for further explanation and examples.
\over   general command for making fractions
{ <subformula1> \over <subformula2> }
Creates a fraction:
numerator:   subformula1
denominator:   subformula2

Examples:
a \over b yields $a \over b$
a+1 \over b+2 yields $a+1 \over b+2$
{a+1 \over b+2}+c yields ${a+1 \over b+2}+c$
see also:     \above,   \abovewithdelims,   \atop,   \atopwithdelims,
  \cfrac,   \dfrac,   \frac,   \genfrac,   \overwithdelims
\overbrace   puts a (stretchy) over-brace over the argument;
can use ‘^’ to place an optional superscript over the overbrace;
can use ‘_’ to place an optional subscript below the argument
\overbrace #1
Example:
\overbrace{x + \cdots + x}^{n\rm\ times}_{\text{(note here)} yields $\overbrace{x + \cdots + x}^{n\rm\ times}_{\text{(note here)}}$

see also:   \underbrace
\overleftarrow
\overrightarrow
\overleftrightarrow
$\overleftarrow{}$
$\overrightarrow{}$
$\overleftrightarrow{}$
&#x2190;stretchy over left arrow
&#x2192;stretchy over right arrow
&#x2194;stretchy over left right arrow
\overleftarrow #1
\overrightarrow #1
\overleftrightarrow #1
Examples:
\overleftarrow{\text{the argument}} yields $\overleftarrow{\text{the argument}}$
\overrightarrow{AB} yields $\overrightarrow{AB}$
\overrightarrow{AB\strut} yields $\overrightarrow{AB\strut}$
\overleftrightarrow{\hspace1in} yields $\overleftrightarrow{\hspace1in}$
\overline $\overline{}$
stretchy overline &#x203E;
\overline #1
Examples:

\overline{AB} yields $\overline{AB}$
\overline a yields $\overline a$
\overline{\text{a long argument}} yields $\overline{\text{a long argument}}$
\overset  
\overset #1 #2
oversets argument #1 (in scriptstyle) over argument #2

Examples:
\overset{\rm top}{\rm bottom} yields $\overset{\rm top}{\rm bottom}$
\overset ab yields $$\overset ab$$
a\,\overset{?}{=}\,b yields $$a\,\overset{?}{=}\,b$$
see also:   \atop,   \underset
\overwithdelims   general command for making fractions;
uses default thickness for fraction bar for current size
{ <subformula1> \overwithdelims <delim1> <delim2> <subformula2> } Creates a fraction:
numerator   subformula1
denominator   subformula2
delim1   is put before the fraction
delim2   is put after the fraction
For an empty delimiter, use ‘.’ in place of the delimiter.

Examples:
a \overwithdelims [ ] b yields $a \overwithdelims [ ] b$
a+1 \overwithdelims . | b+2 yields $a+1 \overwithdelims . | b+2$
{a+1 \overwithdelims \{ \} b+2}+c yields ${a+1 \overwithdelims \{ \} b+2}+c$
see also:     \above,   \abovewithdelims,   \atop,   \atopwithdelims,
  \cfrac,   \dfrac,   \frac,   \genfrac,   \over
\owns $\owns$
see also:   \ni,   \in &#x220B;   class REL
P
\parallel $\parallel$
see also:   \nparallel &#x2225;   class REL
\partial $\partial$
Example:
\frac{\partial f}{\partial x} yields $\frac{\partial f}{\partial x}$
&#x2202;   class ORD
\perp $\perp$
perpendicular to &#x22A5;   class REL
\phantom  
phantom (both horizontal and vertical) class ORD

Sometimes you want to pretend that something is there, for spacing reasons,
but you don't want it to appear—you want it to be invisible—you want it to be a phantom.

The box created by   \phantom   has width, height and depth equal to its argument.
In other words, \phantom   creates horizontal and vertical space equal to that of its argument,
even though the argument isn't visible.
\phantom #1
Examples:
\sqrt{\frac ab}
\sqrt{\phantom{\frac ab}}
yields $ \sqrt{\frac ab} \sqrt{\phantom{\frac ab}} $
\frac{2x+3y-\phantom{5}z}
  {\phantom{2}x+\phantom{3}y+5z}
yields $\displaystyle \frac{2x+3y-\phantom{5}z} {\phantom{2}x+\phantom{3}y+5z}$
\Gamma^{\phantom{i}j}_{i\phantom{j}k}
yields $\displaystyle \Gamma^{\phantom{i}j}_{i\phantom{j}k} $
\matrix{1&-1\cr 2&\phantom{-}3}
yields $\displaystyle \matrix{1&-1\cr 2&\phantom{-}3}$
see also:   \hphantom,   \vphantom
\phi
\Phi
$\phi$
$\Phi$
lowercase Greek letter phi &##x03D5;   class ORD
uppercase Greek letter phi &#x03A6;   class ORD
see also:   \varphi,   \varPhi
\pi
\Pi
$\pi$
$\Pi$
lowercase Greek letter pi &#x03C0;   class ORD
uppercase Greek letter Pi &#x03A0;   class ORD
see also:   \varpi,   \varPi
\pitchforkAMSsymbols
$\pitchfork$
&#x22D4;   class REL
\pm $\pm$
plus or minus &x00B1;   class BIN
see also:   \mp
\pmatrix  
matrix enclosed in parentheses class OPEN
\pmatrix{ <math> & <math> ... \cr <repeat as needed> }
alignment occurs at the ampersands;
a double-backslash can be used in place of the  \cr ;
the final   \\   or   \cr   is optional

Example:
A = \pmatrix{
a_{11} & a_{12} & \ldots & a_{1n} \cr
a_{21} & a_{22} & \ldots & a_{2n} \cr
\vdots & \vdots & \ddots & \vdots \cr
a_{m1} & a_{m2} & \ldots & a_{mn} \cr
}
yields $ A = \pmatrix{ a_{11} & a_{12} & \ldots & a_{1n} \cr a_{21} & a_{22} & \ldots & a_{2n} \cr \vdots & \vdots & \ddots & \vdots \cr a_{m1} & a_{m2} & \ldots & a_{mn} \cr } $
see also:   \matrix
\pmb  
poor man's bold;
it works by duplicating its argument slightly offset,
giving a bold effect (at least in the horizontal direction);
doesn't work well for horizontal lines, like $\,-\,$ or $\,+\,$
class ORD
\pmb #1
Examples:
a \pmb a \boldsymbol a yields $a \pmb a \boldsymbol a$
\pmb{a+b-c}\ \ a+b-c yields $\pmb{a+b-c}\ \ a+b-c$
\pmod $\pmod{}$ parenthesized modulus operator; parenthesized modulo;
18 mu of leading space before the opening parenthesis in display style;
8 mu of leading space before the opening parenthesis in other styles;
6 mu of space after the word  mod
\pmod #1
Examples:
5\equiv 8 \pmod 3 yields $5\equiv 8 \pmod 3$
\pmod{n+m} yields $\pmod{n+m}$
see also:   \mod,   \bmod
\pod $\pod{}$ parenthesized argument with leading space;
18 mu of leading space before the opening parenthesis in display style;
8 mu of leading space before the opening parenthesis in other styles
\pod #1
Examples:

x=y\pod{\text{inline mode}} yields $x=y\pod{\text{inline mode}}$
x=y\pod{\text{display mode}} yields $\displaystyle x=y\pod{\text{display mode}}$
\Pr $\Pr$
does not change size;
default limit placement can be changed using  \limits  and  \nolimits;
does not change size;
see the Big Operators Table for more examples
class OP

Examples:
\Pr_{\rm sub}yields (inline mode)$\Pr_{\rm sub}$
\Pr_{\rm sub}yields (display mode)$\displaystyle\Pr_{\rm sub}$
\prec $\prec$
see also:   \nprec &#x227A;   class REL
\precapproxAMSsymbols
\precnapproxAMSsymbols
$\precapprox$
$\precnapprox$
&#x2AB7;   class REL
&#x2AB9;   class REL
\preccurlyeqAMSsymbols
$\preccurlyeq$
&#x227C;   class REL
\preceq 
\precneqqAMSsymbols
$\preceq$
$\precneqq$
&#x2AAF;   class REL
&#x2AB5;   class REL

see also:   \npreceq
\precsimAMSsymbols
\precnsimAMSsymbols
$\precsim$
$\precnsim$
&#x227E;   class REL
&#x22E8;   class REL
\prime $\prime$
prime character &#x2032;   class ORD
Examples:
f'yields$f'$
f\primeyields$f\prime$
f^\primeyields$f^\prime$
f^{\prime\prime}yields$f^{\prime\prime}$
f''yields$f''$
see also:   \backprime,   prime symbol
\prod $\prod$
changes size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for more examples
&#x220F;   class OP

Examples:
\prod_{j=1}^n yields (in inline mode) $\prod_{j=1}^n$
\prod_{j=1}^n yields (in display mode) $$\prod_{j=1}^n$$
\projlimAMSmath
$\projlim$
projective limit;
does not change size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
class OP

see also:   \varprojlim
\propto $\propto$
see also:   \varpropto &#x221D;   class REL
\psi
\Psi
$\psi$
$\Psi$
lowercase Greek letter psi &#x03C9;   class ORD
uppercase Greek letter psi &#x03A9;   class ORD
see also:   \varPsi
Q
$ \def\mark{\rlap{\normalsize\textstyle |}\kern 1px} $
\quad
\qquad
  \quad   is a 1em space
\qquad   is a 2em space

Examples:
|\quad|\quad| yields $|\quad|\quad|$
|\qquad\hphantom{|}| yields $|\qquad\hphantom{|}|$
R
\raise  
\raise <dimen> #1
raises the argument by the amount specified in <dimen>;
in actual $\rm\TeX$, the argument to  \raise  (and  \lower ) must be an  \hbox ,
but in MathJax it can be any expression (using an \hbox is allowed, but not required)

Example:
h\raise 2pt {ighe} r yields $h\raise 2pt {ighe} r$
see also:   \lower
\rangle $\rangle$
right angle bracket;
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below)
&#x27E9;   class CLOSE

Example:
\left\langle
\matrix{a & b\cr c & d}
\right\rangle
yields $\left\langle \matrix{a & b\cr c & d} \right\rangle$
see also:   \langle
\rbrace $\rbrace$
right brace;
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below)
class CLOSE

Example:
\left\lbrace
\matrix{a & b\cr c & d}
\right\rbrace
yields $\left\lbrace \matrix{a & b\cr c & d} \right\rbrace$
see also:   \lbrace
\rbrack $\rbrack$
right bracket;
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below)
class CLOSE

Examples:

\lbrack \frac ab, c \rbrack yields $\lbrack \frac ab, c \rbrack$
\left\lbrack \frac ab, c \right\rbrack yields $\left\lbrack \frac ab, c \right\rbrack$
see also:   \lbrack,   [ ]
\rceil $\rceil$
right ceiling;
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below)
&#x2309;   class CLOSE

Example:
\left\lceil
\matrix{a & b\cr c & d}
\right\rceil
yields $\left\lceil \matrix{a & b\cr c & d} \right\rceil$
see also:   \lceil,   \lfloor,   \rfloor
\Re $\Re$
&#x211C;   class ORD
\renewcommand   equivalent to \newcommand;
for clarity of code, you may choose to use   \renewcommand   when re-defining a macro;
this is different from actual $\,\rm\TeX\,$,
where  \renewcommand  only allows redefining of an existing command

see also:   \def,   \newcommand,   \newenvironment
\require (non-standard)   This is a MathJax-specific macro that can be used to load MathJax $\rm\TeX$ extensions (like the AMSmath extension) from within math mode, rather than having to include it in the configuration.
For example,
$\require{AMSsymbols}$
would cause MathJax to load the  extensions/TeX/AMSsymbols.js  file at that point.

Since many people use MathJax in blogs and wikis that may not have all the extensions loaded, this makes it possible to load a lesser-used extension on a particular page, without having to include it in every page.
\restrictionAMSsymbols
$\restriction$
&#x21BE;   class REL
\rfloor $\rfloor$
right floor;
non-stretchy when used alone;
stretchy when used with   \left   or   \right
&#x230B;   class CLOSE

see also:   \lfloor,   \lceil,   \rceil
\rgroup $\rgroup$
right group;
non-stretchy when used alone;
stretchy when used with   \left   or   \right
&#x27EE;   class CLOSE

Example:
\left\lgroup
\matrix{a & b\cr c & d}
\right\rgroup
yields $\left\lgroup \matrix{a & b\cr c & d} \right\rgroup$
see also:   \lgroup
\rhdAMSsymbols
$\rhd$
right-hand diamond &#x22B3;   class REL

see also:   \lhd
\rho $\rho$
lowercase Greek letter rho &#x0000;   class ORD

see also:   \varrho
\right    used for stretchy delimiters;
see the Variable-Sized Delimiters Table for details

Can be followed by:
delimiter: sample code: yields:
(   ) \left( \frac12 \right) $\left( \frac12 \right)$
\updownarrow
\Updownarrow
\left\updownarrow \phantom{\frac12} \right\Updownarrow $\left\updownarrow \phantom{\frac12} \right\Updownarrow$

see also:   \left
\rightarrow
\Rightarrow
$\rightarrow$
$\Rightarrow$
non-stretchy&#x2192;   class REL
non-stretchy&#x21D2;   class REL

see also:   \nrightarrow,   \nRightarrow,   \to
\rightarrowtail AMSsymbols
$\rightarrowtail$
right arrow tail; non-stretchy &#x21A3;   class REL

see also:   \leftarrowtail
\rightharpoondown
\rightharpoonup
$\rightharpoondown$
$\rightharpoonup$
non-stretchy&#x21C1;   class REL
non-stretchy&#x21C0;   class REL
see also:   \leftharpoondown,   \rightharpoondown
\rightleftarrowsAMSsymbols
$\rightleftarrows$
right left arrows; non-stretchy &#x21C4;   class REL
\rightleftharpoonsAMSsymbols
$\rightleftharpoons$
right left harpoons; non-stretchy &#x21CC;   class REL
\rightrightarrowsAMSsymbols
$\rightrightarrows$
right right arrows; non-stretchy &#x21C9;   class REL
\rightsquigarrowAMSsymbols
$\rightsquigarrow$
right squiggle arrow; non-stretchy &#x21DD;  class REL
\rightthreetimesAMSsymbols
$\rightthreetimes$
right three times &#x22CC;   class BIN
\risingdotseqAMSsymbols
$\risingdotseq$
rising dot sequence &#x2253;   class REL

see also:   \fallingdotseq
\rlap  
right overlap class ORD
\rlap #1
creates a box of width zero;
the argument is then placed just to the right of this zero-width box
(and hence will overlap whatever lies to the right)

Example:

a\mathrel{\rlap{\;/}{=}}b yields $a\mathrel{\rlap{\;/}{=}}b$
In this example,  {=}  forces the equal to not have  REL  spacing (since it is not adjacent to ORD's);
\mathrel{}  forces the compound symbol (equal with overlapping slash) to be treated as a single REL;
the  \;  improves the spacing for the slash.
see also:   \llap
\rm  
turns on roman;  affects uppercase and lowercase letters, and digits;
also affects uppercase Greek
class ORD
{\rm ... }
Examples:
\rm AaBb\alpha\beta123 yields $\rm AaBb\alpha\beta123$
{\rm A B} A B yields ${\rm A B} A B$
\Delta\Gamma\Lambda{\rm\Delta\Gamma\Lambda} yields $\Delta\Gamma\Lambda{\rm\Delta\Gamma\Lambda}$
\rm AB \bf CD yields $\rm AB \bf CD$
\rm{AB}CD yields $\rm{AB}CD$

see also:   \text,   \hbox,   \mathrm
\rmoustache $\rmoustache$
right moustache;
non-stretchy when used alone;
stretchy when used with   \left   or   \right   (see below)
&#x23B1;   class CLOSE

Example:
\left\lmoustache
\phantom{\matrix{a & b\cr c & d}}
\right\rmoustache
yields $$ \left\lmoustache \phantom{\matrix{a & b\cr c & d}} \right\rmoustache $$
see also:   \lmoustache
\root ... \of  
\root <index> \of #1
Examples:
\root 3 \of x yields $\root 3 \of x$
\root 13 \of {\frac 12} yields $\root 13 \of {\frac 12}$
\root n+1 \of x + 2 yields $\root n+1 \of x + 2 $

see also:   \sqrt,   \leftroot,   \uproot
\RrightarrowAMSsymbols
$\Rrightarrow$
non-stretchy &#x21DB;   class REL
\RshAMSsymbols
$\Rsh$
right shift; non-stretchy
&#x21B1;   class REL

see also:   \Lsh
\rtimesAMSsymbols
$\rtimes$
see also:   \ltimes &#x22CA;   class BIN
\Rule (non-standard)   a MathJax-specific macro giving a rule with a specified width, height, and depth
\Rule <dimenWidth> <dimenHeight> <dimenDepth>
where each argument is a dimension

Examples:
x\Rule{3px}{1ex}{2ex}x yields $x\Rule{3px}{1ex}{2ex}x$
x\Rule{3px}{2ex}{1ex}x yields $x\Rule{3px}{2ex}{1ex}x$
\rvertAMSmath
\rVertAMSmath
$\rvert$
$\rVert$
&#x2223;   class CLOSE
&#x2225;   class CLOSE
both non-stretchy when used alone;
stretchy when used with   \left   or   \right

Example:
\left\lvert\frac{\frac ab}{\frac cd}\right\rvert yields $\left\lvert\frac{\frac ab}{\frac cd}\right\rvert$
see also:   \lvert,   \lVert,   |,   \|
S
\S $\S$
section symbol &#xA700;   class ORD
\scr  
turns on script typestyle for uppercase letters;
lowercase letters are in a roman typestyle
class ORD
{ \scr ... }
Examples:
\scr ABCDEFGHIJKLMNOPQRSTUVWXYZ yields $\scr ABCDEFGHIJKLMNOPQRSTUVWXYZ$
\scr 0123456789abcdefghijklmnopqrstuvwxyz yields $\scr 0123456789abcdefghijklmnopqrstuvwxyz$
0123456789abcdefghijklmnopqrstuvwxyz yields $0123456789abcdefghijklmnopqrstuvwxyz$
{\scr AB}AB yields ${\scr AB}AB$
\scr AB \rm AB yields $\scr AB \rm AB$
\scr{AB}CD yields $\scr{AB}CD$

see also:   \mathscr
\scriptscriptstyle  
used to over-ride automatic style rules and force scriptscript style;
stays in force until the end of math mode or the braced group, or until another style is selected
class ORD

{ \scriptscriptstyle ... }
Example:
In inline mode:
\frac ab+\displaystyle\frac ab+\textstyle\frac ab+\scriptstyle\frac ab+\scriptscriptstyle\frac ab
yields:
$\frac ab + \displaystyle\frac ab+\textstyle\frac ab+\scriptstyle\frac ab+\scriptscriptstyle\frac ab$

Example:
In inline mode:
\frac ab + {\scriptscriptstyle \frac cd + \frac ef} + \frac gh
yields
$\frac ab + {\scriptscriptstyle \frac cd + \frac ef} + \frac gh$

Example:
In inline mode:
\frac ab + \scriptscriptstyle{\frac cd + \frac ef} + \frac gh
yields
$\frac ab + \scriptscriptstyle{\frac cd + \frac ef} + \frac gh$

see also: \displaystyle,   \scriptstyle,   \textstyle
\scriptsize   
turns on script size class ORD
{ \scriptsize ... }
Example:
\rm \scriptsize script \normalsize normal \large large yields $\rm \scriptsize script \normalsize normal \large large$

see also:   \normalsize
\scriptstyle  
used to over-ride automatic style rules and force script style;
stays in force until the end of math mode or the braced group, or until another style is selected
class ORD

{ \scriptstyle ... }
Example:
In inline mode:
\frac ab+\displaystyle\frac ab+\textstyle\frac ab+\scriptstyle\frac ab+\scriptscriptstyle\frac ab
yields:
$\frac ab + \displaystyle\frac ab+\textstyle\frac ab+\scriptstyle\frac ab+\scriptscriptstyle\frac ab$

Example:
In inline mode:
\frac ab + {\scriptstyle \frac cd + \frac ef} + \frac gh
yields
$\frac ab + {\scriptstyle \frac cd + \frac ef} + \frac gh$

Example:
In inline mode:
\frac ab + \scriptstyle{\frac cd + \frac ef} + \frac gh
yields
$\frac ab + \scriptstyle{\frac cd + \frac ef} + \frac gh$

see also: \displaystyle,   \scriptscriptstyle,   \textstyle
\searrow $\searrow$
southeast arrow; non-stretchy &#x2198;   class ORD
see also:   \nearrow,   \nwarrow,   \swarrow
\sec $\sec$
secant;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples
class OP

Examples:
\sec x yields $\sec x$
\sec(2x-1) yields $\sec(2x-1)$
see also:   \csc
\setminus $\setminus$
set minus &#x2216;   class BIN

Examples:
A\setminus B yields $A\setminus B$
A\backslash B yields $A\backslash B$
see also:   \backslash
\sf  
turns on sans serif mode for uppercase and lowercase letters and digits, and for uppercase Greek class ORD
{ \sf ... }
Examples:
\sf ABCDEFGHIJKLMNOPQRSTUVWXYZ yields $\sf ABCDEFGHIJKLMNOPQRSTUVWXYZ$
\sf 0123456789 yields $\sf 0123456789$
\sf abcdefghijklmnopqrstuvwxyz yields $\sf abcdefghijklmnopqrstuvwxyz$
ABCDE 01234 abcde yields $ABCDE 01234 abcde$
{\sf AB\Delta\Gamma\Lambda}\ AB\Delta\Gamma\Lambda yields ${\sf AB\Delta\Gamma\Lambda}\ AB\Delta\Gamma\Lambda$
\sf AB \rm AB yields $\sf AB \rm AB$
\sf{AB}CD yields $\sf{AB}CD$

see also:   \mathsf
\sharp $\sharp$
musical sharp symbol &#x266F;   class ORD

see also:   \flat,   \natural
\shortmidAMSsymbols
$\shortmid$
see also:   \nshortmid,   \mid &#x2223;   class REL
\shortparallelAMSsymbols
$\shortparallel$
see also:   \nshortparallel &#x2225;   class REL
\shoveleftAMSmath
\shoverightAMSmath
  forces flush left or flush right typesetting in a   \multline   or   \multline*   environment (see examples)

Example:
\begin{multline}
(a+b+c+d)^2 \\
+ (e+f)^2 + (g+h)^2 + (i+j)^2 + (k+l)^2 \\
+ (m+n)^2 + (o+p)^2 + (q+r)^2 + (s+t)^2 + (u+v)^2  \\
+ (w+x+y+z)^2
\end{multline}
yields $$ \begin{multline} (a+b+c+d)^2 \\ + (e+f)^2 + (g+h)^2 + (i+j)^2 + (k+l)^2 \\ + (m+n)^2 + (o+p)^2 + (q+r)^2 + (s+t)^2 + (u+v)^2 \\ + (w+x+y+z)^2 \end{multline} $$ Example:
\begin{multline}
(a+b+c+d)^2 \\
\shoveleft{+ (e+f)^2 + (g+h)^2 + (i+j)^2 + (k+l)^2} \\
\shoveright{+ (m+n)^2 + (o+p)^2 + (q+r)^2 + (s+t)^2 + (u+v)^2}  \\
+ (w+x+y+z)^2
\end{multline}
yields $$ \begin{multline} (a+b+c+d)^2 \\ \shoveleft{+ (e+f)^2 + (g+h)^2 + (i+j)^2 + (k+l)^2} \\ \shoveright{+ (m+n)^2 + (o+p)^2 + (q+r)^2 + (s+t)^2 + (u+v)^2} \\ + (w+x+y+z)^2 \end{multline} $$
\sidesetAMSmath
  used for putting symbols at the four ‘corners’ of a large operator (like $\displaystyle\sum$ or $\displaystyle\prod$ )
\sideset{_#1^#2}{_#3^#4} <large operator>
where:
  • #1 = lower left
  • #2 = upper left
  • #3 = lower right
  • #4 = upper right
Examples:
\sideset{_1^2}{_3^4}\sum yields $$\sideset{_1^2}{_3^4}\sum$$
\sigma
\Sigma
$\sigma$
$\Sigma$
lowercase Greek letter sigma &#x03C3;   class ORD
uppercase Greek letter sigma &#x03A3;   class ORD

see also:   \sum,   \varsigma,   \varSigma
\sim
\simeq
$\sim$
$\simeq$
&#x223C;   class REL
&#x2243;   class REL

see also:   \nsim
\sin $\sin$
sine;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples
class OP

Examples:
\sin x yields $\sin x$
\sin(2x-1) yields $\sin(2x-1)$

see also:   \cos
\sinh $\sinh$
hyperbolic sine;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples
class OP

Examples:
\sinh x yields $\sinh x$
\sinh(2x-1) yields $\sinh(2x-1)$

see also:   \cosh
\skew   used to finely adjust the positioning on accents;
particularly useful for adjusting superaccents (accents on accents);
usually requires trial-and-error adjustment for proper positioning
\skew #1 <accent>
where #1 is a positive integer (the skew amount)

Examples:
\hat A yields $\hat A$
\skew7\hat A yields $\skew7\hat A$
\tilde M yields $\tilde M$
\skew{8}\tilde M yields $\skew{8}\tilde M$
\hat{\hat A} yields $\hat{\hat A}$
\skew4\hat{\hat A} yields $\skew4\hat{\hat A}$
\small  
turns on small size; affects all math class ORD
{\small ... }
Example:
\rm\tiny tiny \Tiny Tiny
\small small \normalsize normal
\large lg \Large Lg \LARGE LG
\huge hg \Huge Hg
yields $ \rm\tiny tiny \Tiny Tiny \small small \normalsize normal \large lg \Large Lg \LARGE LG \huge hg \Huge Hg $
\def\myExp{\alpha\frac xy}
\tiny\myExp \Tiny\myExp
\small\myExp \normalsize\myExp
\large\myExp \Large\myExp \LARGE\myExp
\huge\myExp \Huge\myExp
yields $ \def\myExp{\alpha\frac xy} \tiny\myExp \Tiny\myExp \small\myExp \normalsize\myExp \large\myExp \Large\myExp \LARGE\myExp \huge\myExp \Huge\myExp $
ab{\small cd} cd yields $ab{\small cd} cd$
ab\small{cd} cd yields $ab\small{cd} cd$

see also:   \tiny,   \Tiny,   \normalsize,   \large,   \Large,   \LARGE,   \huge,   \Huge
\smallfrownAMSsymbols
$\smallfrown$
small frown &#x2322;   class REL

see also:   \frown,   \smile,   \smallsmile
\smallint $\smallint$
small integral &#x222B;   class OP

see also:   \int
\smallsetminusAMSsymbols
$\smallsetminus$
small set minus &#x2216;   class BIN

see also:   \setminus
\smallsmileAMSsymbols
$\smallsmile$
small smile &#x2323;   class REL

see also:   \smile,   \frown,   \smallfrown
\smash  
By using \smash, \phantom, \hphantom, \vphantom, \rlap, \llap,
you can typeset any mathematics,
yet give it the width and/or height and/or depth of any other mathematics.
\smash #1
Typesets the argument in a box with the same width as the argument,
but with height and depth equal to zero.
In other words: the argument of   \smash   is visible, and has its natural width,
but does not contribute any height or depth to the surrounding mathematics
(hence leaving the surrounding mathematics to dictate height and depth).
class ORD
Here are some scenarios:
  • to vertically   \smash   the box containing   this   and make it instead behave vertically like   that  :
    \smash{this}\vphantom{that}

    Examples:
    \sqrt{\frac ab}
    \sqrt{\smash{7}\vphantom{\frac ab}}
    
    yields $ \sqrt{\frac ab} \sqrt{\smash{7}\vphantom{\frac ab}} $
    \sqrt{\frac{\frac ab}{\frac cd}}
    \sqrt{\smash{\frac ef}\vphantom{\frac{\frac ab}{\frac cd}}}
    
    yields $ \sqrt{\frac{\frac ab}{\frac cd}} \sqrt{\smash{\frac ef}\vphantom{\frac{\frac ab}{\frac cd}}} $
  • to horizontally compress the box containing   this   and make it instead behave horizontally like   that  :
    \rlap{this}\hphantom{that}
    or
    \hphantom{that}\llap{this}

    Examples:
    \sqrt{\rm very\ wide}
    \sqrt{\rlap{\rm thin}\hphantom{\rm very\ wide}}
    
    yields $ \sqrt{\rm very\ wide} \sqrt{\rlap{\rm thin}\hphantom{\rm very\ wide}} $
    \sqrt{\rm very\ wide}
    \sqrt{\hphantom{\rm very\ wide}\llap{\rm thin}}
    
    yields $ \sqrt{\rm very\ wide} \sqrt{\hphantom{\rm very\ wide}\llap{\rm thin}} $
  • to both vertically smash and horizontally compress the box containing   this  
    and make it instead behave both vertically and horizontally like   that  :
    \rlap{\smash{this}}\phantom{that}
    or
    \phantom{that}\llap{\smash{this}}

    Examples:
    \sqrt{\matrix{a & b\cr c & d}}
    \sqrt{
    \rlap{\smash{\rm Hi!}}
    \phantom{\matrix{a & b\cr c & d}}
    }
    
    yields $ \sqrt{\matrix{a & b\cr c & d}} \sqrt{ \rlap{\smash{\rm Hi!}} \phantom{\matrix{a & b\cr c & d}} } $
see also:   \hphantom,   \vphantom,   \phantom,   \llap,   \rlap
\smile $\smile$
smile &#x2323;   class REL

see also:   \smallsmile,   \frown,   \smallfrown
\space  
Example:
a\space b yields $a\space b$
&#xA0;   class ORD
in MathJax, this is the same as:   \ (backslash space), \nobreakspace
\Space (non-standard)   a MathJax-specific macro giving space with a specified width, height, and depth
\Space <dimenWidth> <dimenHeight> <dimenDepth>
where each argument is a dimension

Compare:
a\Rule{5px}{4ex}{2ex}^b_c d yields $a\Rule{5px}{4ex}{2ex}^b_c d$
a\Space{5px}{4ex}{2ex}^b_c d yields $a\Space{5px}{4ex}{2ex}^b_c d$
see also:   \Rule
\spadesuit $\spadesuit$
see also:   \clubsuit,   \diamondsuit,   \heartsuit &#x2660;   class ORD
\sphericalangleAMSsymbols
$\sphericalangle$
&#x2222;   class ORD
\sqcap
\sqcup
$\sqcap$
$\sqcup$
square cap&#x2293;   class BIN
square cup&#x2294;   class BIN
\sqrt $\sqrt{}$
square root (and other roots) class ORD
\sqrt #1
\sqrt[n]{op}   is equivalent to   \root n \of {op}
Examples:
\sqrt x yields $\sqrt x$
\sqrt xy yields $\sqrt xy$
\sqrt{xy} yields $\sqrt{xy}$
\sqrt[3]{x+1} yields $\sqrt[3]{x+1}$

see also:   \root
\sqsubsetAMSsymbols
\sqsupsetAMSsymbols
$\sqsubset$
$\sqsupset$
square subset&#x228F;   class REL
square superset&#x2290;   class REL
\sqsubseteq
\sqsupseteq
$\sqsubseteq$
$\sqsupseteq$
&#x2291;   class REL
&#x2292;   class REL
\squareAMSsymbols
$\square$
  &#x25A1;   class ORD
\stackrel   stack relations;
you can stack anything (not just relations) but it creates an item of class  REL 
(and usually the bottom is a  REL  to start with, but doesn't have to be)
\stackrel #1 #2
where #1 (in superscript style) is stacked on top of #2

Examples:
\stackrel{\rm def}{=} yields $\stackrel{\rm def} {=}$
\stackrel{\rm top}{\rm bottom} yields $\stackrel{\rm top}{\rm bottom}$
\star $\star$
&#x22C6;   class BIN
\strut   an invisible box with no width, height 8.6pt and depth 3pt;
note that   \mathstrut   changes with the current size, but   \strut   does not

Examples:
\sqrt{(\ )}
\sqrt{\mathstrut\rm mathstrut}
\sqrt{\strut\rm strut}
yields $ \sqrt{(\ )} \sqrt{\mathstrut\rm mathstrut} \sqrt{\strut\rm strut} $
\Tiny
\sqrt{(\ )}
\sqrt{\mathstrut\rm mathstrut}
\sqrt{\strut\rm strut}
yields $ \Tiny \sqrt{(\ )} \sqrt{\mathstrut\rm mathstrut} \sqrt{\strut\rm strut} $
\Large
\sqrt{(\ )}
\sqrt{\mathstrut\rm mathstrut}
\sqrt{\strut\rm strut}
yields $ \Large \sqrt{(\ )} \sqrt{\mathstrut\rm mathstrut} \sqrt{\strut\rm strut} $
see also:   \mathstrut
\style   [HTML] non-standard;
used to apply CSS styling to mathematics
\style #1 #2
where:
  • #1  is a (single) CSS style declaration
  • #2  is the mathematics to be styled
Examples:
\frac{\style{color:red}{x+1}}{y+2}
yields $\frac{\style{color:red}{x+1}}{y+2}$
\style{background-color:yellow}{\frac{x+1}{y+2}}
yields $\style{background-color:yellow}{\frac{x+1}{y+2}}$

Example:

Consider the following HTML/Javascript/MathJax code:
<button type="button" onclick="makeVisible()">Click to reveal answer</button>

<script type="text/javascript">
function makeVisible() {
document.getElementById('answer').style.visibility = "visible";
}
</script>

$$
(x+1)^2 = \cssId{answer}\style{visibility:hidden}{(x+1)(x+1)}
$$
Then, the result of this HTML/Javascript/MathJax code is:

$$ (x+1)^2 = \cssId{answer}{\style{visibility:hidden}{(x+1)(x+1)}} $$
see also:   \class,   \cssId
\subset $\subset$
&#x2282;   class REL
\SubsetAMSsymbols
$\Subset$
&#x22D0;   class REL
\subseteq 
\subsetneqAMSsymbols
\subseteqqAMSsymbols
\subsetneqqAMSsymbols
$\subseteq$
$\subsetneq$
$\subseteqq$
$\subsetneqq$
&#x2286;   class REL
&#x228A;   class REL
&#x2AC5;   class REL
&#x2ACB;   class REL
see also:   \nsubseteq,   \nsubseteqq,   \varsubsetneq,   \varsubsetneqq
\substackAMSmath
  use for multi-line subscripts or superscripts

Examples:
\sum_{
\substack{
1\lt i\lt 3 \\
1\le j\lt 5
}}
a_{ij}
yields (display mode) $$\sum_{ \substack{ 1\lt i\lt 3 \\ 1\le j\lt 5 }} a_{ij} $$
^{\substack{\text{a very} \\
\text{contrived} \\
\text{example}
}}
{\frac ab}_{\substack{
\text{isn't} \\
\text{it?}
}}
yields (display mode) $$ ^{\substack{\text{a very} \\ \text{contrived} \\ \text{example} }} {\frac ab}_{\substack{ \text{isn't} \\ \text{it?} }} $$

see also:   \begin{subarray}
\succ $\succ$
see also:   \nsucc &#x227B;   class REL
\succapproxAMSsymbols
\succnapproxAMSsymbols
$\succapprox$
$\succnapprox$
&#x2AB8;   class REL
&#x2ABA;   class REL
\succcurlyeqAMSsymbols
$\succcurlyeq$
  &#x227D;   class REL
\succeq 
\succneqqAMSsymbols
$\succeq$
$\succneqq$
&#x2AB0;   class REL
&#x2AB6;   class REL
see also:   \nsucceq
\succsimAMSsymbols
\succnsimAMSsymbols
$\succsim$
$\succnsim$
&#x227F;   class REL
&#x22E9;   class REL
\sum $\sum$
summation notation;
changes size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
&#x2211;   class OP

see also:   \Sigma
\sup $\sup$
supremum;
greatest lower bound;
does not change size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
class OP

Examples:
\sup_{\rm limit}yields (inline mode)$\sup_{\rm limit}$
\sup_{\rm limit}yields (display mode)$\displaystyle\sup_{\rm limit}$
see also:   \inf
\supset $\supset$
&#x2283;   class REL
\SupsetAMSsymbols
$\Supset$
&#x22D1;   class REL
\supseteq 
\supsetneqAMSsymbols
\supseteqqAMSsymbols
\supsetneqqAMSsymbols
$\supseteq$
$\supsetneq$
$\supseteqq$
$\supsetneqq$
&#x2287;   class REL
&#x228B;   class REL
&#x2AC6;   class REL
&#x2ACC;   class REL
see also:   \nsupseteq,   \nsupseteqq,   \varsupsetneq,   \varsupsetneqq
\surd $\surd$
&#x221A;   class ORD
\swarrow $\swarrow$
southwest arrow; non-stretchy &#x2199;   class REL

see also:   \nearrow,   \nwarrow,   \searrow
T
\tagAMSmath
  used primarily in AMS math environments to get tags (equation numbers, labels);
can, however, be used on any equation;
the argument of  \tag  is typeset in text mode, but math mode can be used within the text:
for example,  \tag{\$\bullet\$} 
You can use dollar signs in text-mode regardless of the settings of the  inlineMath  delimiters in the tex2jax preprocessor.
\tag #1

Example:
\eqalign{
3x - 4y &= 5\cr
x + 7 &= -2y
} 
\tag{3.1c}
yields $\eqalign{ 3x - 4y &= 5\cr x + 7 &= -2y } \tag{3.1c} $
\tan $\tan$
tangent;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples
class OP

Examples:
\tan x yields $\tan x$
\tan(2x-1) yields $\tan(2x-1)$
see also:   \cot
\tanh $\tanh$
hyperbolic tangent;
does not change size;
default limit placement is the same in both inline and display modes;
can change limit placement using \limits;
see the Big Operators Table for more examples
class OP

Examples:
\tanh x yields $\tanh x$
\tanh(2x-1) yields $\tanh(2x-1)$

see also:   \cosh,   \sinh
\tau $\tau$
lowercase Greek letter tau &#x03C4;   class ORD
\tbinomAMSmath
  notation commonly used for binomial coefficients; in textstyle
\tbinom #1 #2
Examples:
\tbinom n k yields (inline mode) $\tbinom nk$
\tbinom n k yields (display mode) $\displaystyle\tbinom nk$
\binom n k yields (display mode) $\displaystyle\binom nk$
\tbinom{n-1}k-1 yields $\binom{n-1}k-1$
\tbinom{n-1}{k-1} yields $\tbinom{n-1}{k-1}$
see also:   \binom,   \choose,   \dbinom
\TeX $\TeX$
the TeX logo class ORD

Examples:
\TeX yields $\TeX$
\rm\TeX yields $\rm\TeX$

see also:   \LaTeX
\text
\textbf
\textit
\textrm
 
text
boldface text
italic text
roman text

used to produce text-mode material (in a given font) within a mathematical expression;
MathJax does not process any macros within the text (unlike $\rm\TeX$ itself);
you can get math mode within the text using  \(...\)  delimiters
class ORD
\text #1
\textbf #1
\textit #1
\textrm #1
Example:

|x| = x \text{ for all \(x \ge 0\)} yields $|x| = x \text{ for all \(x \ge 0\)}$
\text{\alpha in text mode }\alpha yields $\text{\alpha in text mode }\alpha$
\textbf{\alpha in textbf mode }\alpha yields $\textbf{\alpha in textbf mode }\alpha$
\textit{\alpha in textit mode }\alpha yields $\textit{ \alpha in textit mode }\alpha$
\textrm{\alpha in textrm mode }\alpha yields $\textrm{\alpha in textrm mode }\alpha$

in MathJax,  \text  is the same as:   \hbox,   \mbox
see also:   \rm
\textstyle  
used to over-ride automatic style rules and force text (inline) style;
stays in force until the end of math mode or the braced group, or until another style is selected
class ORD
{ \textstyle ... }
Example:
In display mode:
\frac ab + {\textstyle \frac cd + \frac ef} + \frac gh
yields
$\displaystyle\frac ab + {\textstyle \frac cd + \frac ef} + \frac gh$

Example:
In inline mode:
\frac ab+{\displaystyle\frac ab}+\frac ab+\scriptstyle\frac ab+\scriptscriptstyle\frac ab
yields:
$\frac ab + {\displaystyle\frac ab}+\frac ab+\scriptstyle\frac ab+\scriptscriptstyle\frac ab$

see also:   \displaystyle,   \scriptstyle,   \scriptscriptstyle
\tfracAMSmath
  textstyle fraction
\tfrac #1 #2
Examples:
\tfrac ab \frac ab (display mode) yields $\displaystyle\tfrac ab \frac ab$
\tfrac ab \frac ab (inline mode) yields $\tfrac ab \frac ab$

see also:   \frac,   \dfrac
\thereforeAMSsymbols
$\therefore$
&#x2234   class REL
\theta
\Theta
$\theta$
$\Theta$
lowercase Greek letter theta&#x03B8;   class ORD
uppercase Greek letter theta&#x0398;   class ORD
see also:   \vartheta,   \varTheta
\thickapproxAMSsymbols
$\thickapprox$
Example:
approx\ \ \thickapprox   yields   $\approx\ \ \thickapprox $
&#x2248;   class REL

see also:   \approx
\thicksimAMSsymbols
$\thicksim$
Example:
sim\ \ \thicksim   yields   $\sim\ \ \thicksim $
&#x223C;   class REL
\thinspace   thin space; normally $\frac 16$ of a quad

Example:
thinspaces between letters:   $a\thinspace b\thinspace c\thinspace d$

see also:   symbols for spaces,   \negthinspace
\tilde $\tilde{}$
non-stretchy tilde accent &#x02DC;
\tilde #1
Usually, #1 is a single letter;  otherwise, accent is centered over argument.

Examples:
\tilde e yields $\tilde e$
\tilde E yields $\tilde E$
\tilde eu yields $\tilde eu$
\tilde{eu} yields $\tilde{eu}$
\times $\times$
  &#x00D7;   class BIN
\tiny  
turns on tiny; a bit smaller than \Tiny class ORD
{\tiny ... }
Examples:
\tiny AaBb\alpha\beta123 yields $\tiny AaBb\alpha\beta123$
{\tiny A B} A B yields ${\tiny A B} A B$
\tiny AB \Tiny CD yields $\tiny AB \Tiny AB$
\tiny{AB}CD yields $\tiny{AB}CD$
\Tinynon-standard
 
turns on Tiny; a bit bigger than \tiny class ORD
{\Tiny ... }
Examples:
\Tiny AaBb\alpha\beta123 yields $\Tiny AaBb\alpha\beta123$
{\Tiny A B} A B yields ${\Tiny A B} A B$
\Tiny AB \tiny CD yields $\Tiny AB \tiny AB$
\Tiny{AB}CD yields $\Tiny{AB}CD$
\to $\to$
non-stretchy &#x2192;   class REL
see also:   \rightarrow
tool tips   Tool tips are not built into MathJax, but you can click here to benefit from
a posting by Davide P. Cervone (April 2011) at the MathJax Users Group.
\top $\top$
  &#x22A4;   class ORD
\triangle 
\triangledownAMSsymbols
$\triangle$
$\triangledown$
&#x25B3;   class ORD
&#x25BD;   class ORD

see also:   \ntriangleleft,   \ntriangleright,   \vartriangle,   \vartriangleleft,   \vartriangleright
\triangleleft 
\triangleright 
$\triangleleft$
$\triangleright$
&#x25C3;   class BIN
&#x25B9;   class BIN

see also:   \ntriangleleft,   \ntriangleright,   \vartriangle,   \vartriangleleft,   \vartriangleright
\trianglelefteqAMSsymbols
\trianglerighteqAMSsymbols
$\trianglelefteq$
$\trianglerighteq$
&#x22B4;   class REL
&#x22B5   class REL

see also:   \ntrianglelefteq,   \ntrianglerighteq
\triangleqAMSsymbols
$\triangleq$
&#x225C;   class REL
\tt  
turns on typewriter type class ORD
{\tt ... }
Examples:
\tt AaBb\alpha\beta123 yields $\tt AaBb\alpha\beta123$
{\tt A B} A B yields ${\tt A B} A B$
\tt AB \rm CD yields $\tt AB \rm AB$
\tt{AB}CD yields $\tt{AB}CD$
\twoheadleftarrowAMSsymbols
\twoheadrightarrowAMSsymbols
$\twoheadleftarrow$
$\twoheadrightarrow$
non-stretchy &#x219E;   class REL
non-stretchy&#x21A0;   class REL
U
\ulcornerAMSsymbols
\urcornerAMSsymbols
$\ulcorner$
$\urcorner$
upper left corner &#x250C;   class REL
upper right corner &#x2510;   class REL
These are technically delimiters, but MathJax doesn't stretch them.
They are valid after  \left,  \right, and the various  \big  commands.

see also:   \llcorner,   \lrcorner
\underbrace   puts a (stretchy) under-brace under the argument;
can use ‘^’ to place an optional superscript over the argument;
can use ‘_’ to place an optional subscript below the underbrace
\underbrace #1
Example:
\underbrace{x + \cdots + x}_{n\rm\ times}^{\text{(note here)} yields $\underbrace{x + \cdots + x}_{n\rm\ times}^{\text{(note here)}}$

see also:   \overbrace
\underleftarrow
\underrightarrow
\underleftrightarrow
$\underleftarrow{}$
$\underrightarrow{}$
$\underleftrightarrow{}$
stretchy under left arrow &#x2190;
stretchy under right arrow &#x2192;
stretchy under left right arrow &#x2194;
\underleftarrow #1
\underrightarrow #1
\underleftrightarrow #1
Examples:
\underleftarrow{\text{the argument}} yields $\underleftarrow{\text{the argument}}$
\underrightarrow{AB} yields $\underrightarrow{AB}$
\underrightarrow{AB\strut} yields $\underrightarrow{AB\strut}$
\underleftrightarrow{\hspace1in} yields $\underleftrightarrow{\hspace1in}$
\underline $\underline{}$
stretchy underline &#x005F;

\underline #1
Examples:

\underline{AB} yields $\underline{AB}$
\underline a yields $\underline a$
\underline{\text{a long argument}} yields $\underline{\text{a long argument}}$
\underset  
\underset #1 #2
undersets argument #1 (in scriptstyle) under argument #2;
the top item is properly aligned with the surrounding text (their baselines match)

Examples:
\underset{\rm bottom}{\rm top} yields $\underset{\rm bottom}{\rm top}$
\underset ab yields $$\underset ab$$
see also:   \overset
\unicodenon-standard
 
implements a  \unicode{}  extension to $\rm\TeX$ that allows arbitrary unicode code points to be entered in mathematics;
can optionally specify height and depth of character (width is determined by browser);
can optionally specify the default font from which to take the character;
once a size and font are provided for a given unicode point, they need not be specified again in subsequent  \unicode{}  calls for that character

See MathJax TeX and LateX Support; Unicode Support for more details.
class ORD
\unicode[optHeight,optDepth][optFont]#1
Examples:
\unicode{x263a} yields $\unicode{x263a}$  
&#x263a; yields (in math mode) $☺$  
\unicode[.55,0.05]{x22D6} yields $\unicode[.55,0.05]{x22D6}$ less-than with dot, with
height 0.55em and depth 0.05em
\unicode[.55,0.05][Geramond]{x22D6} yields $\unicode[.55,0.05][Geramond]{x22D6}$ same, taken from Geramond font
\unicode[Geramond]{x22D6} yields $\unicode[Geramond]{x22D6}$ same, but with default (height,depth) of (0.8em,0.2em)
\unlhdAMSsymbols
\unrhdAMSsymbols
$\unlhd$
$\unrhd$
underlined left-hand (left-pointing) diamond &#x22B4;   class REL
underlined right-hand (right-pointing) diamond &#x22B5;   class REL
\uparrow
\Uparrow
$\uparrow$
$\Uparrow$
non-stretchy &#x2191;   class REL
non-stretchy &#x21D1;   class REL
\updownarrow
\Updownarrow
$\updownarrow$
$\Updownarrow$
non-stretchy &#x2195;   class REL
non-stretchy &#x21D5;   class REL
\upharpoonleftAMSsymbols
\upharpoonrightAMSsymbols
$\upharpoonleft$
$\upharpoonright$
non-stretchy &#x21BF;   class REL
non-stretchy &#x21BE;   class REL
\uplus $\uplus$
&#x228E;   class BIN
\uproot   used to fine-tune the placement of the index inside   \sqrt   or   \root   (see examples)
\sqrt[... \uproot #1 ...]{...}
\root ... \uproot #1 ... \of {...}
where the argument is a small integer:
a positive integer moves the index up;
a negative integer moves the index down

In actual TeX,  \uproot  is not allowed in  \root ,
so this is a difference between MathJax and $\rm\TeX$.

Examples:
\sqrt[3]{x} yields $\sqrt[3]{x}$
\sqrt[3\uproot2]{x} yields $\sqrt[3\uproot2]{x}$
\root 3 \of x yields $\root 3 \of x$
\root 3\uproot{-2} \of x yields $\root 3\uproot{-2} \of x$

see also:   \leftroot,   \root
\upsilon
\Upsilon
$\upsilon$
$\Upsilon$
lowercase Greek letter upsilon &#x03C5;   class ORD
uppercase Greek letter upsilon &#x03A5;   class ORD
see also:   \varupsilon,   \varUpsilon
\upuparrowsAMSsymbols
$\upuparrows$
non-stretchy &#x21C8;   class REL
V
\varDeltaAMSsymbols
$\varDelta$
uppercase Greek letter delta; variant &#x0394;   class ORD

see also:   \Delta
\varepsilon
$\varepsilon$
lowercase Greek letter epsilon; variant &#x03B5;   class ORD

see also:   \epsilon
\varGammaAMSsymbols
$\varGamma$
uppercase Greek letter gamma; variant &#x0393;   class ORD

see also:   \Gamma
\varinjlimAMSmath
$\varinjlim$
injective limit; variant;
does not change size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples
class OP

see also:   \injlim
\varkappaAMSsymbols
$\varkappa$
lowercase Greek letter kappa; variant &#x03F0;   class ORD

see also:   \kappa
\varLambdaAMSsymbols
$\varLambda$
uppercase Greek letter lambda; variant &#x039B;   class ORD

see also:   \Lambda
\varlimsupAMSmath
\varliminfAMSmath
$\varlimsup$
$\varliminf$
limit superior; variant class OP
limit inferior; variant class OP
do not change size;
can change limit placement using  \limits  and  \nolimits;
see the Big Operators Table for examples

see also:   \limsup,   \liminf
\varnothingAMSsymbols
$\varnothing$
see also:   \emptyset &#x2205;   class ORD
\varOmegaAMSsymbols
$\varOmega$
uppercase Greek letter omega; variant &#x03A9;   class ORD

see also:   \Omega
\varphi $\varphi$
lowercase Greek letter phi; variant &#x03C6;   class ORD

see also:   \phi
\varPhiAMSsymbols
$\varPhi$
uppercase Greek letter phi; variant &#x03A6;   class ORD

see also:   \Phi
\varpi $\varpi$
lowercase Greek letter pi; variant &#x03D6;   class ORD

see also:   \pi
\varPiAMSsymbols
$\varPi$
uppercase Greek letter pi; variant &#x03A0;   class ORD

see also:   \Pi
\varprojlimAMSmath
$\varprojlim$ projective limit; variant;
does not change size;
can change limit placement using \limits and \nolimits;
see the Big Operators Table for examples

see also:   \projlim
\varproptoAMSsymbols
$\varpropto$
proportional to; variant &#x221D;   class REL

see also:   \propto
\varPsiAMSsymbols
$\varPsi$
uppercase Greek letter pi; variant &#x03A8;   class ORD

see also:   \Psi
\varrhoAMSsymbols
$\varrho$
lowercase Greek letter rho; variant &#x03F1;   class ORD

see also:   \rho
\varsigmaAMSsymbols
$\varsigma$
lowercase Greek letter sigma; variant &#x03C2;   class ORD

see also:   \sigma
\varSigmaAMSsymbols
$\varSigma$
uppercase Greek letter sigma; variant &#x03C2;   class ORD

see also:   \Sigma
\varsubsetneqAMSsymbols
\varsubsetneqqAMSsymbols
$\varsubsetneq$
$\varsubsetneqq$
&#x228A;   class REL
&#x2ACB;   class REL

see also:   \subsetneq,   \subsetneqq
\varsupsetneqAMSsymbols
\varsupsetneqqAMSsymbols
$\varsupsetneq$
$\varsupsetneqq$
&#x228B;   class REL
&#x2ACC;   class REL

see also:   \supsetneq,   \supsetneqq
\vartheta 
\varThetaAMSsymbols
$\vartheta$
$\varTheta$
lowercase Greek letter theta; variant&#x03D1;   class ORD
uppercase Greek letter theta; variant&#x0398;   class ORD

see also:   \theta,   \Theta
\vartriangleAMSsymbols
\vartriangleleftAMSsymbols
\vartrianglerightAMSsymbols
$\vartriangle$
$\vartriangleleft$
$\vartriangleright$
&#x25B3;   class REL
&#x22B2;   class REL
&#x22B3;   class REL
see also:   \triangle,   \triangleleft,   \triangleright
\varUpsilonAMSsymbols
$\varUpsilon$
uppercase Greek letter upsilon; variant &#x03A5;   class ORD

see also:   \upsilon
\varXiAMSsymbols
$\varXi$
uppercase Greek letter xi; variant &#x039E;   class ORD

see also:   \Xi
\vcenter  
\vcenter #1
centers the argument on the ‘math axis’,
which is at half the height of an ‘x’, or about the position of a minus sign;
one of the reasons for  \vcenter  is to get stretchy delimiters to match the contents better

Examples:
\left(\Rule{1ex}{2em}{0pt}\right) yields $\left(\Rule{1ex}{2em}{0pt}\right)$
\left(\vcenter{\Rule{1ex}{2em}{0pt}}\right) yields $\left(\vcenter{\Rule{1ex}{2em}{0pt}}\right)$
\left(\frac{a+b}{\dfrac{c}{d}}\right) yields $$\left(\frac{a+b}{\dfrac{c}{d}}\right)$$
\left(\vcenter{\frac{a+b}{\dfrac{c}{d}}}\right) yields $$\left(\vcenter{\frac{a+b}{\dfrac{c}{d}}}\right)$$
\vdash $\vdash$
see also:   \nvdash &#x22A2;   class REL
\VdashAMSsymbols
\vDashAMSsymbols
$\Vdash$
$\vDash$
&#x22A9;   class REL
&#x22A8;   class REL

see also:   \nVdash,   \nvDash
\vdots $\vdots$
vertical dots &#x22EE;   class ORD
\vec   non-stretchy vector symbol
\vec #1
Examples:
\vec v yields $\vec v$
\vec{AB} yields $\vec{AB}$

see also:   \overrightarrow
\vee $\vee$
see also:   \lor &#x2228;   class BIN
\veebarAMSsymbols
$\veebar$
  &#x22BB;   class BIN
\verb   verbatim mode;
useful for code snippets and for displaying special characters ‘as is’ (i.e., not interpreted by MathJax).
Only works in display mode.
Usually, verbatim content is typeset in a sans serif font.
\verb $\diamond$ <non-interpreted material> $\diamond$
where   $\diamond$   denotes a non-letter character that does not appear in the <non-interpreted material>.

To use  \verb  :
  • First look through the material that is to be typeset ‘as is’ (verbatim).
  • Choose a non-letter character that does not appear in this material.
  • This chosen non-letter character will mark the beginning and end of the verbatim material,
    as illustrated in the examples below.

Examples (in display mode):

\verb*$x^2\sqrt y$* \text{ yields } x^2\sqrt y

yields:
$$\verb*$x^2\sqrt y$* \text{ yields } x^2\sqrt y$$
\verb!Text and $\frac ab$ in \verb mode!

yields:
$$\verb!Text and $\frac ab$ in \verb mode!$$
\vert
\Vert
$\vert$
$\Vert$
class ORD
&#x2225;   class ORD
both non-stretchy when used alone; stretchy when used with   \left   or   \right

see also:   |,   \|,   \lvert,   \lVert,   \rvert,   \rVert
\vphantom   vertical phantom

Sometimes you want to pretend that something is there, for spacing reasons,
but you don't want it to appear—you want it to be invisible—you want it to be a phantom.

The box created by   \vphantom   has the height and depth of its argument,
but its width is zero (so it doesn't contribute to any horizontal spacing issues).
In other words, \vphantom   creates vertical space equal to that produced by its argument,
but doesn't create any horizontal space.
\vphantom #1
Examples:
\binom{\frac ab}c \binom{\vphantom{\frac ab}?}c yields $$\binom{\frac ab}c \binom{\vphantom{\frac ab}?}c$$
see also:   \phantom,   \hphantom,   \smash
\VvdashAMSsymbols
$\Vvdash$
  &#x22AA;   class REL
W
\wedge $\wedge$
see also:   \land &#x2227;   class BIN
\widehat $\widehat{\ \ \ }$
stretchy hat accent &#x02C6;
\widehat #1
Examples:
\widehat a yields $\widehat a$
\widehat A yields $\widehat A$
\widehat AB yields $\widehat AB$
\widehat{AB} yields $\widehat{AB}$

see also:   \hat
\widetilde $\widetilde{\ \ \ }$
stretchy tilde accent &#x02DC;
\widetilde #1
Examples:
\widetilde a yields $\widetilde a$
\widetilde A yields $\widetilde A$
\widetilde AB yields $\widetilde AB$
\widetilde{AB} yields $\widetilde{AB}$
\wp $\wp$
‘wriggly’ letter p &#x2118;   class ORD
\wr $\wr$
‘wriggle’ symbol;
&#x2240;   class BIN
X
\Xi $\Xi$
uppercase Greek letter xi &#x039E;   class ORD

see also:   \varXi
\xi $\xi$
lowercase Greek letter xi &#x03BE;   class ORD
\xleftarrowAMSmath
\xrightarrowAMSmath
 
stretchy arrows with mathematical overset and optional mathematical underset class REL
\xleftarrow[optionalArgument] #1
\xrightarrow[optionalArgument] #1
where the optional arguments (inside brackets, if desired) appear below the arrows (see examples).

Examples:
\xrightarrow a yields $\xrightarrow a$
\xrightarrow ab yields $\xrightarrow ab$
\xrightarrow{ab} yields $\xrightarrow{ab}$
\xleftarrow{\text{see equation (1)}} yields $\xleftarrow{\text{see equation (1)}}$
\xrightarrow[f]{\text{see (1)}} yields $\xrightarrow[f]{\text{see (1)}}$
Y
\yenAMSsymbols
$\yen$
  &#x00A5;   class ORD
Z
\zeta $\zeta$
lowercase Greek letter zeta &#x03B6;   class ORD
environments

$\rm\LaTeX$ environments of the form   \begin{XXX} ... \end{XXX}   are provided, as listed in the table below.
The  processEnvironments  value in the  tex2jax  block of the MathJax configuration controls processing behavior:

See the tex2jax Preprocessor for details.

alignAMSmath
\begin{align}
 ... \end{align}
   For vertical alignment of two or more lines at one or more places:
  • ampersand(s) ‘&’ are used to indicate desired alignments (see examples below)
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates lines
  • individual lines may be tagged using the \tag{} command:
    • default input for  \tag{}  is text
    • you may get mathematical content inside  \tag{}  by using math delimiters;
      e.g., \tag{$\alpha$}

EXAMPLES:

Alignment at a single location:
  • use a single ampersand where alignment should occur
  • you may tag (or not tag) any desired subset of lines
\begin{align}
(a+b)^2 &= (a+b)(a+b)          \tag{3.1c}      \\
        &= a^2 + ab + ba + b^2 \tag{$\dagger$} \\
        &= a^2 + 2ab + b^2     \tag{$\ast$}
\end{align}
yields $$ \begin{align} (a+b)^2 &= (a+b)(a+b) \tag{3.1c} \\ &= a^2 + ab + ba + b^2 \tag{$\dagger$} \\ &= a^2 + 2ab + b^2 \tag{$\ast$} \end{align} $$ Alignment at more than one location is trickier.
It is best illustrated with an example:  
see also:   \eqalign,   \eqalignno,   \leqalignno,   \begin{aligned}
align*AMSmath
  [May 2011] same as align
alignatAMSmath
\begin{alignat}{<num>}
... \end{alignat}
  For vertical alignment of two or more lines at one or more places;
produces a more horizontally-compressed display than align:
  • the alignat environment is started with   \begin{alignat}{<num>} ,
    where   num   is a positive integer ($1,2,3,\ldots$) that indicates the number of places
    where alignment is desired
  • ampersand(s) ‘&’ are used to indicate desired alignments (see examples below)
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates lines
  • individual lines may be tagged using the \tag{} command:
    • default input for  \tag{}  is text
    • you may get mathematical content inside  \tag{}  by using math delimiters;
      e.g., \tag{$\alpha$}
Let $n$ denote the number of places where alignment is desired.
Then, there will be $2n - 1$ ampersands used, as follows:
  • STEP 1:
    The odd-numbered ampersands (1st, 3rd, 5th, etc.) are placed where alignment is desired.
    Position these ampersands first:
    a   &= bbbbbb &=   cc   &= d \\
    aaa &=  bbbb  &= cccccc &= ddd
    
  • STEP 2:
    Now, focus attention on the content between the previously-positioned ampersands.
    What part of this content belongs on the left? On the right?
    In each group, use an ampersand to separate the content into two pieces (a piece may be empty).
    Think of this ampersand as a solid ‘wall’ that is pushing content to the left or right.

    Compare these three scenarios:
    Pushing all content to the left:
    \begin{alignat}{3}
    a   &= bbbbbb& &=   cc&   &= d \tag{3.1} \\
    aaa &=  bbbb&  &= cccccc& &= ddd \tag{3.2}
    \end{alignat}
    
    yields $$ \begin{alignat}{3} a &= bbbbbb& &= cc& &= d \tag{3.1}\\ aaa &= bbbb& &= cccccc& &= ddd \tag{3.2} \end{alignat} $$
    Pushing all content to the right:
    \begin{alignat}{3}
    a   &= &bbbbbb &=   &cc   &= d \\
    aaa &=  &bbbb  &= &cccccc &= ddd
    \end{alignat}
    
    yields $$ \begin{alignat}{3} a &= &bbbbbb &= &cc &= d \\ aaa &= &bbbb &= &cccccc &= ddd \end{alignat} $$
    Splitting the content, with half left and half right:
    \begin{alignat}{3}
    a   &= bbb&bbb &=   c&c   &= d \\
    aaa &=  bb&bb  &= ccc&ccc &= ddd
    \end{alignat}
    
    yields $$ \begin{alignat}{3} a &= bbb&bbb &= c&c &= d \\ aaa &= bb&bb &= ccc&ccc &= ddd \end{alignat} $$

see also:   \eqalignat,   \eqalignatno,   \leqalignatno,   \begin{alignedat}
alignat*AMSmath
  [May 2011] same as alignat
alignedAMSmath
  same as \begin{align}, but allows only a single tag, which is vertically centered on the group

Examples:
\begin{aligned}
\tag{3.1}
x_1 &= 1\cr
x_2 &= 1 + 2\cr
x_3 &= 1 + 2 + 3
\end{aligned}
\begin{aligned}
x_1 &= 1 \tag{3.1}\cr
x_2 &= 1 + 2\cr
x_3 &= 1 + 2 + 3
\end{aligned}
\begin{aligned}
x_1 &= 1\cr
x_2 &= 1 + 2\cr
\tag{3.1} x_3 &= 1 + 2 + 3
\end{aligned}
all yield the same display:
$$ \begin{aligned} \tag{3.1} x_1 &= 1\cr x_2 &= 1 + 2\cr x_3 &= 1 + 2 + 3 \end{aligned} $$
alignedatAMSmath
  same as \begin{alignat}, but allows only a single tag, which is vertically centered on the group

Examples:
\begin{alignedat}{1}
\tag{3.1}
x_1 &= 1\cr
x_2 &= 1 + 2\cr
x_3 &= 1 + 2 + 3
\end{alignedat}
\begin{alignedat}{1}
x_1 &= 1 \tag{3.1}\cr
x_2 &= 1 + 2\cr
x_3 &= 1 + 2 + 3
\end{alignedat}
\begin{alignedat}{1}
x_1 &= 1\cr
x_2 &= 1 + 2\cr
\tag{3.1} x_3 &= 1 + 2 + 3
\end{alignedat}
all yield the same display:
$$ \begin{alignedat}{1} \tag{3.1} x_1 &= 1\cr x_2 &= 1 + 2\cr x_3 &= 1 + 2 + 3 \end{alignedat} $$
array 
\begin{array}
{<justification info>}
... \end{array}
   Used to create an array (matrix),
where columns can be individually left-justified, centered, or right-justified.
  • suppose that $n$ columns are desired in the array;
    then, $n-1$ ampersands are used to separate the columns
  • the array environment is started with   \begin{array}{<justification info>} ,
    where   <justification info>   is a series of $n$ letters, one for each column:
    • ‘l’ for left-justified
    • ‘c’ for centered
    • ‘r’ for right-justified
    • pipe character(s) ‘|’ can be used in the justification information to specify optional separating vertical line(s) (see example below)
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Compare these scenarios:
both columns left-justified:
\begin{array}{ll}
aaa & b\cr
c   & ddd
\end{array}
yields
$$ \begin{array}{ll} aaa & b\cr c & ddd \end{array} $$

both columns right-justified:
\begin{array}{rr}
aaa & b\cr
c   & ddd
\end{array}
yields
$$ \begin{array}{rr} aaa & b\cr c & ddd \end{array} $$

both columns centered, with separating line:
\begin{array}{c|c}
aaa & b\cr
c   & ddd
\end{array}
yields
$$ \begin{array}{c|c} aaa & b\cr c & ddd \end{array} $$

first column left-justified; second column right-justified:
\begin{array}{lr}
aaa & b\cr
c & ddd
\end{array}
yields
$$ \begin{array}{lr} aaa & b\cr c & ddd \end{array} $$


Putting a pipe character ‘|’ at the beginning or end of the justification info encloses the entire structure, which is different from standard $\,\rm\TeX\,$:
\begin{array}{|lr}
aaa & b\cr
c & ddd
\end{array}
yields
$$ \begin{array}{|lr} aaa & b\cr c & ddd \end{array} $$
see also:   \begin{matrix},   \begin{subarray}
Bmatrix 
\begin{Bmatrix}
... \end{Bmatrix}
  Used to create a matrix (an array) with braces $\{\,,\,\}$ as enclosing delimiters;
columns are centered.
  • suppose that $n$ columns are desired in the array;
    then, $n-1$ ampersands are used to separate the columns
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Example:
\begin{Bmatrix}
aaa & b\cr
c   & ddd
\end{Bmatrix}
yields $$ \begin{Bmatrix} aaa & b\cr c & ddd \end{Bmatrix} $$
see also:   \begin{array},   \begin{matrix}
bmatrix 
\begin{bmatrix}
... \end{bmatrix}
  Used to create a matrix (an array) with brackets $[\,,\,]$ as enclosing delimiters;
columns are centered.
  • suppose that $n$ columns are desired in the array;
    then, $n-1$ ampersands are used to separate the columns
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Example:
\begin{bmatrix}
aaa & b\cr
c   & ddd
\end{bmatrix}
yields $$ \begin{bmatrix} aaa & b\cr c & ddd \end{bmatrix} $$
see also:   \begin{array},   \begin{matrix}
cases 
\begin{cases}
... \end{cases}
  Used for piecewise-defined functions
  • an ampersand ‘&’ is used to separate the function cases and their definitions
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Example:
|x| =
\begin{cases}
x  & \text{ if } x\ge 0 \\
-x & \text{ if } x \lt 0
\end{cases}
yields $$ |x| = \begin{cases} x & \text{ if } x\ge 0 \\ -x & \text{ if } x \lt 0 \end{cases} $$
see also:   \cases
eqnarray 
\begin{eqnarray}
... \end{eqnarray}
  for ‘equation arrays’;
aligns at one or more places;
surround the character(s) to be aligned with ampersands, as shown below;
content between alignment characters (or between alignment characters and end-of-line) is left-justified;
a double backslash ‘\\’ or carriage return ‘\cr’ separates rows

Examples:
\begin{eqnarray}
y &=& (x-1)^2 \\
  &=& (x-1)(x-1) \\
  &=& x^2 - 2x + 1
\end{eqnarray}
yields
$$ \begin{eqnarray} y &=& (x-1)^2 \\ &=& (x-1)(x-1) \\ &=& x^2 - 2x + 1 \end{eqnarray} $$
\begin{eqnarray}
(x-1)^2 &=& (x-1)(x-1)      &=&  x^2-2x + 1 \\
(x-1)^3 &=& (x-1)(x-1)(x-1) &=&  (x-1)^2(x-1) 
\end{eqnarray}
yields
$$ \begin{eqnarray} (x-1)^2 &=& (x-1)(x-1) &=& x^2-2x + 1 \\ (x-1)^3 &=& (x-1)(x-1)(x-1) &=& (x-1)^2(x-1) \end{eqnarray} $$
eqnarray*   [May 2011] same as equarray
equation 
\begin{equation}
... \end{equation}
  [May 2011] ignored, until MathJax implements automatic numbering
equation*   [May 2011] ignored
gatherAMSmath
  to display any number of centered formulas (without any alignment);
a double backslash ‘\\’ or carriage return ‘\cr’ separates rows;
individual lines may be tagged using the \tag{} command:
  • default input for  \tag{}  is text
  • you may get mathematical content inside  \tag{}  by using math delimiters;
    e.g., \tag{$\alpha$}

Example:
\begin{gather}
a = a \tag{$*$}\\
\text{if } a=b \text{ then } b=a \tag{$\dagger$}\\
\text{if } a=b \text{ and } b=c \text{ then } a=c\tag{3.1}
\end{gather}
yields:
$$ \begin{gather} a = a \tag{$*$}\\ \text{if } a=b \text{ then } b=a \tag{$\dagger$}\\ \text{if } a=b \text{ and } b=c \text{ then } a=c \tag{3.1} \end{gather} $$ see also:   \displaylines,   \begin{gathered}
gather*AMSmath
  [May 2011] same as gather
gatheredAMSmath
  same as \begin{gather}, but allows only a single tag, which is vertically centered on the group

Examples:
\begin{gathered}
\tag{3.1}
x = 1\cr
y = 2\cr
z = 3
\end{gathered}
\begin{gathered}
x = 1 \tag{3.1}\cr
y = 2\cr
z = 3
\end{gathered}
\begin{gathered}
x = 1\cr
y = 2\cr
\tag{3.1} z = 3
\end{gathered}
all yield the same display:
$$ \begin{gathered} x = 1\cr y = 2\cr \tag{3.1} z = 3 \end{gathered} $$
matrix 
\begin{matrix}
 ... \end{matrix}
  Used to create a matrix (an array) without any enclosing delimiters;
columns are centered.
  • suppose that $n$ columns are desired in the array;
    then, $n-1$ ampersands are used to separate the columns
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Example:
\begin{matrix}
aaa & b\cr
c   & ddd
\end{matrix}
yields $$ \begin{matrix} aaa & b\cr c & ddd \end{matrix} $$
see also:   \begin{array}
multlineAMSmath
\begin{multline}
... \end{multline}
  a multi-line environment;
typically used for formulas/equations that don't fit on a single line
  • the first (or only) line is displayed left-justified
  • the last line is displayed right-justified
  • any intermediate line(s) are centered
The justification of intermediate lines can be adjusted with \shoveleft and \shoveright.

Examples:
\begin{multline}
\rm first\ line \\
\rm second\ line \\
\rm third\ line \\
\rm fourth\ line
\end{multline}
yields:
$$ \begin{multline} \rm first\ line \\ \rm second\ line \\ \rm third\ line \\ \rm fourth\ line \end{multline} $$
\begin{multline}
\rm first\ line \\
\shoveleft\rm second\ line \\
\shoveright\rm third\ line \\
\rm fourth\ line
\end{multline}
yields:
$$ \begin{multline} \rm first\ line \\ \shoveleft\rm second\ line \\ \shoveright\rm third\ line \\ \rm fourth\ line \end{multline} $$ see also:   \begin{split}
multline* [AMSmath]   [May 2011] same as multline
see also:   \shoveleft,   \shoveright
pmatrix 
\begin{pmatrix}
... \end{pmatrix}
  Used to create a matrix (an array) with parentheses $(\,,\,)$ as enclosing delimiters;
columns are centered.
  • suppose that $n$ columns are desired in the array;
    then, $n-1$ ampersands are used to separate the columns
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Example:
\begin{pmatrix}
aaa & b\cr
c   & ddd
\end{pmatrix}
yields $$ \begin{pmatrix} aaa & b\cr c & ddd \end{pmatrix} $$
see also:   \begin{array},   \begin{matrix}
smallmatrixAMSmath
\begin{smallmatrix}
... \end{smallmatrix}
  Used to create a small matrix (an array);
particularly suited for use in text;
columns are centered.
  • suppose that $n$ columns are desired in the array;
    then, $n-1$ ampersands are used to separate the columns
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Examples:
the matrix
$\begin{smallmatrix}
aaa & b\cr
c   & ddd
\end{smallmatrix}$
is...
yields the matrix $ \begin{smallmatrix} aaa & b\cr c & ddd \end{smallmatrix} $ is...
\left[
\begin{smallmatrix}
aaa & b\cr
c   & ddd
\end{smallmatrix}
\right]
yields (in display mode) $$ \left[ \begin{smallmatrix} aaa & b\cr c & ddd \end{smallmatrix} \right] $$
\left[
\begin{smallmatrix}
aaa & b\cr
c   & ddd
\end{smallmatrix}
\right]
yields (in inline mode) $ \left[ \begin{smallmatrix} aaa & b\cr c & ddd \end{smallmatrix} \right] $
see also:   \begin{array},   \begin{matrix}
splitAMSmath
  for single equations that are too long to fit on one line, and hence must be split into multiple lines;
allows for (optional) alignment at one or more places, using ‘&’ to mark alignment points

Examples:
\begin{split}
\text{first line}\\
&\text{first aligned place}           &\text{second aligned place}  \\
&\text{and more first aligned}\qquad  &\text{and more second aligned} \\
\text{no ampersands on this line} \\
&                                     &\text{aligned at second place} \\
\text{no amps here either}
\end{split}
yields: $$ \begin{split} \text{first line}\\ &\text{first aligned place} &\text{second aligned place} \\ &\text{and more first aligned}\qquad &\text{and more second aligned} \\ \text{no ampersands on this line} \\ & &\text{aligned at second place} \\ \text{no amps here either} \end{split} $$ see also:   \begin{multline}
subarray 
\begin{subarray}
{<justification info>}
... \end{subarray}
   a more compact version of \begin{array};
can be used for multi-subscripts and multi-superscripts on large operators;
columns can be individually left-justified, centered, or right-justified
  • suppose that $n$ columns are desired in the subarray;
    then, $n-1$ ampersands are used to separate the columns
  • the subarray environment is started with   \begin{subarray}{<justification info>} ,
    where   <justification info>   is a series of $n$ letters, one for each column:
    • ‘l’ for left-justified
    • ‘c’ for centered
    • ‘r’ for right-justified
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Example:
\prod_{\begin{subarray}{rl}
i\lt 5                 & j\gt 1 \\
k\ge2,\,k\ne 5 \quad    & \ell\le 5,\,\ell\ne 2
\end{subarray}}
x_{ijk\ell}
yields $$ \prod_{\begin{subarray}{rl} i\lt 5\quad & j\gt 1 \\ k\ge2,\,k\ne 5 \quad & \ell\le 5,\,\ell\ne 2 \end{subarray}} x_{ijk\ell} $$ see also:   \substack,   \begin{array}
Vmatrix 
\begin{Vmatrix}
... \end{Vmatrix}
  Used to create a matrix (an array) with $\|\,,\,\|$ as enclosing delimiters;
columns are centered.
  • suppose that $n$ columns are desired in the array;
    then, $n-1$ ampersands are used to separate the columns
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Example:
\begin{Vmatrix}
aaa & b\cr
c   & ddd
\end{Vmatrix}
yields $$ \begin{Vmatrix} aaa & b\cr c & ddd \end{Vmatrix} $$
see also:   \begin{array},   \begin{matrix}
vmatrix 
\begin{vmatrix}
... \end{vmatrix}
  Used to create a matrix (an array) with $|\,,\,|$ as enclosing delimiters;
columns are centered.
  • suppose that $n$ columns are desired in the array;
    then, $n-1$ ampersands are used to separate the columns
  • a double backslash ‘\\’ or carriage return ‘\cr’ separates rows
Example:
\begin{vmatrix}
aaa & b\cr
c   & ddd
\end{vmatrix}
yields $$ \begin{vmatrix} aaa & b\cr c & ddd \end{vmatrix} $$
see also:   \begin{array},   \begin{matrix}