Input Syntax
Entering Characters
• Enter it directly (e.g. ) 
• Enter it by full name (e.g. ) 
• Enter it by alias (e.g. Esc a Esc) (notebook front end only) 
• Enter it by choosing from a palette (notebook front end only) 
• Enter it by character code (e.g. ) 
Typical ways to enter characters.
All printable ASCII characters can be entered directly. Those that are not alphanumeric are assigned explicit names in
Mathematica, allowing them to be entered even on keyboards where they do not explicitly appear.
 \[RawSpace] 
!  \[RawExclamation] 
"  \[RawDoubleQuote] 
#  \[RawNumberSign] 
$  \[RawDollar] 
%  \[RawPercent] 
&  \[RawAmpersand] 
'  \[RawQuote] 
(  \[RawLeftParenthesis] 
)  \[RawRightParenthesis] 
*  \[RawStar] 
+  \[RawPlus] 
,  \[RawComma] 
  \[RawDash] 
.  \[RawDot] 
/  \[RawSlash] 
:  \[RawColon] 

;  \[RawSemicolon] 
<  \[RawLess] 
=  \[RawEqual] 
>  \[RawGreater] 
?  \[RawQuestion] 
@  \[RawAt] 
[  \[RawLeftBracket] 
\  \[RawBackslash] 
]  \[RawRightBracket] 
^  \[RawWedge] 
_  \[RawUnderscore] 
`  \[RawBackquote] 
{  \[RawLeftBrace] 
  \[RawVerticalBar] 
}  \[RawRightBrace] 
~  \[RawTilde] 

Full names for nonalphanumeric printable ASCII characters.
All characters which are entered into the
Mathematica kernel are interpreted according to the setting for the
CharacterEncoding option for the stream from which they came.
\[Name]  a character with the specified full name 
\nnn  a character with octal code nnn 
\.nn  a character with hexadecimal code nn 
\:nnnn  a character with hexadecimal code nnnn 
Ways to enter characters.
Codes for characters can be generated using
ToCharacterCode. The Unicode standard is followed, with various extensions.
8bit characters have codes less than 256; 16bit characters have codes between 256 and 65535. Approximately 900 characters are assigned explicit names in
Mathematica. Other characters must be entered using their character codes.
\\  single backslash (decimal code 92) 
\  single space (decimal code 32) 
\"  double quote (decimal code 34) 
\b  backspace or Ctrl+H (decimal code 8) 
\t  tab or Ctrl+I (decimal code 9) 
\n  newline or Ctrl+J (decimal code 10; full name ) 
\f  form feed or Ctrl+L (decimal code 12) 
\r  carriage return or Ctrl+M (decimal code 13) 
\000  null byte (code 0) 
Some special 8bit characters.
Types of Input Syntax
The standard input syntax used by
Mathematica is the one used by default in
InputForm and
StandardForm. You can modify the syntax by making definitions for
MakeExpression.
Options can be set to specify what form of input should be accepted by a particular cell in a notebook or from a particular stream.
The input syntax in
TraditionalForm, for example, is different from that in
InputForm and
StandardForm.
In general, what input syntax does is to determine how a particular string or collection of boxes should be interpreted as an expression. When boxes are set up, say with the notebook front end, there can be hidden
InterpretationBox or
TagBox objects which modify the interpretation of the boxes.
Character Strings
 a character string 
 a literal in a character string 
 a literal in a character string 
(at end of line)  ignore the following newline 
 a substring representing twodimensional boxes 
Entering character strings.
Character strings can contain any sequence of 8 or 16bit characters. Characters entered by name or character code are stored the same as if they were entered directly.
In a notebook front end, text pasted into a string by default automatically has appropriate \ characters inserted so that the string stored in
Mathematica reproduces the text that was pasted.
Within
any box structures represented using backslash sequences can be used.
StringExpression objects can be used to represent strings that contain symbolic constructs, such as pattern elements.
Symbol Names and Contexts
name  symbol name 
`name  symbol name in current context 
context`name  symbol name in specified context 
context`  context name 
context1`context2`  compound context name 
`context`  context relative to the current context 
Symbol names and contexts.
Symbol names and contexts can contain any characters that are treated by
Mathematica as letters or letterlike forms. They can contain digits but cannot start with them. Contexts must end in a backquote
.
Numbers
digits  integer 
digits.digits  approximate number 
base^^digits  integer in specified base 
base^^digits.digits  approximate number in specified base 
mantissa*^n  scientific notation (mantissa×) 
base^^mantissa*^n  scientific notation in specified base (mantissa×) 
number`  machineprecision approximate number 
number`s  arbitraryprecision number with precision 
number``s  arbitraryprecision number with accuracy 
Input forms for numbers.
Numbers can be entered with the notation
in any base from
to
. The base itself is given in decimal. For bases larger than
, additional digits are chosen from the letters

or

. Upper and lowercase letters are equivalent for these purposes. Floatingpoint numbers can be specified by including
in the
digits sequence.
In scientific notation,
mantissa can contain
marks. The exponent
must always be an integer, specified in decimal.
The precision or accuracy
can be any real number; it does not need to be an integer.
In the form
the precision
is given in decimal, but it gives the effective number of digits of precision in the specified base, not in base 10.
An approximate number
is taken to be machine precision if the number of digits given in it is
Ceiling[$MachinePrecision]+1 or less. If more digits are given, then
is taken to be an arbitraryprecision number. The accuracy of
is taken to be the number of digits that appear to the right of the decimal point, while its precision is taken to be
Log[10, Abs[x]]+Accuracy[x].
A number entered in the form
0``s is taken to have precision 0 and accuracy
.
Bracketed Objects
Bracketed objects use explicit left and right delimiters to indicate their extent. They can appear anywhere within
Mathematica input, and can be nested in any way.
The delimiters in bracketed objects are
matchfix operators. But since these delimiters explicitly enclose all operands, no precedence need be assigned to such operators.
(*any text*)  comment 
(expr)  parenthesization: grouping of input 
Bracketed objects without commaseparated elements.
Comments can be nested, and can continue for any number of lines. They can contain any 8 or 16bit characters.
Parentheses must enclose a single complete expression; neither
nor
are allowed.
{e_{1},e_{2},...}  List[e_{1},e_{2},...] 
e_{1},e_{2},...  AngleBracket[e_{1},e_{2},...] 
expr  Floor[expr] 
expr  Ceiling[expr] 
e_{1},e_{2},...  BracketingBar[e_{1},e_{2},...] 
e_{1},e_{2},...  DoubleBracketingBar[e_{1},e_{2},...] 
\(input\)  input or grouping of boxes 
Bracketed objects that allow commaseparated elements.
The notation
... is used to stand for any sequence of expressions.
can include any number of elements, with successive elements separated by commas.
is
List, a list with zero elements.
can be entered as
.
The character
can be used interchangeably with ordinary commas; the only difference is that
will not be displayed.
When the delimiters are special characters, it is a convention that they are named
and
.
is used to enter boxes using onedimensional strings. Note that within the outermost
in a piece of input the syntax used is slightly different from outside, as described in
"Input of Boxes".
h[e_{1},e_{2},...]  standard expression 
e[[i_{1},i_{2},...]]  Part[e,i_{1},i_{2},...] 
ei_{1},i_{2},...  Part[e,i_{1},i_{2},...] 
Bracketed objects with heads.
Bracketed objects with heads explicitly delimit all their operands except the head. A precedence must be assigned to define the extent of the head.
The precedence of
is high enough that
is interpreted as
Not. However,
is interpreted as
.
TwoDimensional Input Forms
x^{y}  Power[x,y] 
 Divide[x,y] 
 Sqrt[x] 
 Power[x,1/n] 
a_{11}  a_{12}  ... 
a_{21}  a_{22}  ... 
 {{a_{11},a_{12},...},{a_{21},a_{22},...}} 
_{x}y  D[y,x] 
_{x,...}y  D[y,x,...] 

y x  Integrate[y,{x,x_{min},x_{max}}] 
x  Integrate[y w/z,{x,x_{min},x_{max}}] 
y  Sum[y,{x,x_{min},x_{max}}] 
y  Product[y,{x,x_{min},x_{max}}] 

Twodimensional input forms with builtin evaluation rules.
Any array of expressions represented by a
GridBox is interpreted as a list of lists. Even if the
GridBox has only one row, the interpretation is still
.
In the form
the limits
and
can be omitted, as can
and
.
Twodimensional input forms without builtin evaluation rules.
There is no issue of precedence for forms such as
and
in which operands are effectively spanned by the operator. For forms such as
and
a left precedence does need to be specified, so such forms are included in the main table of precedences above.
Input of Boxes
• Use a palette 
• Use control keys 
Ways to input boxes.
Control Keys
Ctrl+2 or Ctrl+@  square root 
Ctrl+5 or Ctrl+%  switch to alternate position (e.g. subscript to superscript) 
Ctrl+6 or Ctrl+^  superscript 
Ctrl+7 or Ctrl+&  overscript 
Ctrl+9 or Ctrl+(  begin a new cell within an existing cell 
Ctrl+0 or Ctrl+)  end a new cell within an existing cell 
Ctrl+ or Ctrl+_  subscript 
Ctrl+4 or Ctrl+$  underscript 
Ctrl+Enter  create a new row in a table 
Ctrl+,  create a new column in a table 
Ctrl+.  expand current selection 
Ctrl+/  fraction 
Ctrl+Space  return from current position or state 
Ctrl+, Ctrl+, Ctrl+, Ctrl+  move an object by minimal increments on the screen 
Standard control keys.
On Englishlanguage keyboards both forms will work where alternates are given. On other keyboards the first form should work but the second may not.
Boxes Constructed from Text
When textual input that you give is used to construct boxes, as in
StandardForm or
TraditionalForm cells in a notebook, the input is handled slightly differently from when it is fed directly to the kernel.
The input is broken into
tokens, and then each token is included in the box structure as a separate character string. Thus, for example,
is broken into the tokens
,
,
.
• symbol name (e.g. ) 
• number (e.g. ) 
• operator (e.g. ) 
• spacing (e.g. ) 
• character string (e.g. ) 
Types of tokens in text used to construct boxes.
A
RowBox is constructed to hold each operator and its operands. The nesting of
RowBox objects is determined by the precedence of the operators in standard
Mathematica syntax.
Note that spacing characters are not automatically discarded. Instead, each sequence of consecutive such characters is made into a separate token.
StringBased Input
\(...\)  input raw boxes 
\!\(...\)  input and interpret boxes 
Inputting raw and interpreted boxes.
Any textual input that you give between
and
is taken to specify boxes to construct. The boxes are only interpreted if you specify with
that this should be done. Otherwise
is left for example as
SuperscriptBox, and is not converted to
Power.
Within the outermost
, further
specify grouping and lead to the insertion of
RowBox objects.
\(box_{1},box_{2},...\)  RowBox[box_{1},box_{2},...] 
box_{1}\^box_{2}  SuperscriptBox[box_{1},box_{2}] 
box_{1}\_box_{2}  SubscriptBox[box_{1},box_{2}] 
box_{1}\_box_{2}\%box_{3}  SubsuperscriptBox[box_{1},box_{2},box_{3}] 
box_{1}\&box_{2}  OverscriptBox[box_{1},box_{2}] 
box_{1}\+box_{2}  UnderscriptBox[box_{1},box_{2}] 
box_{1}\+box_{2}\%box_{3}  UnderoverscriptBox[box_{1},box_{2},box_{3}] 
box_{1}\/box_{2}  FractionBox[box_{1},box_{2}] 
\@box  SqrtBox[box] 
form\` box  FormBox[box,form] 
\*input  construct box by interpreting input 
\  insert a space 
\n  insert a newline 
\t  indent at the beginning of a line 
Stringbased ways of constructing raw boxes.
In stringbased input between
and
spaces, tabs and newlines are discarded.
can be used to insert a single space. Special spacing characters such as
\[ThinSpace],
\[ThickSpace], or
\[NegativeThinSpace] are not discarded.
When you input typesetting forms into a string, the internal representation of the string uses the above forms. The front end displays the typeset form, but uses the
notation when saving the content to a file or when sending the string to the kernel for evaluation.
The Extent of Input Expressions
Mathematica will treat all input that you give on a single line as being part of the same expression.
Mathematica allows a single expression to continue for several lines. In general, it treats the input that you give on successive lines as belonging to the same expression whenever no complete expression would be formed without doing this.
Thus, for example, if one line ends with
, then
Mathematica will assume that the expression must continue on the next line. It will do the same if for example parentheses or other matchfix operators remain open at the end of the line.
If at the end of a particular line the input you have given so far corresponds to a complete expression, then
Mathematica will normally begin immediately to process that expression.
You can however explicitly tell
Mathematica that a particular expression is incomplete by putting a
or a
(
\[Continuation]) at the end of the line.
Mathematica will then include the next line in the same expression, discarding any spaces or tabs that occur at the beginning of that line.
Special Input
?symbol  get information 
??symbol  get more information 
?s_{1}s_{2}...  get information on several objects 
!command  execute an external command (textbased interface only) 
!!file  display the contents of an external file (textbased interface only) 
Special input lines.
In most implementations of
Mathematica, you can give a line of special input anywhere in your input. The only constraint is that the special input must start at the beginning of a line.
Some implementations of
Mathematica may not allow you to execute external commands using
!command.
Front End Files
Notebook files as well as front end initialization files can contain a subset of standard
Mathematica language syntax. This syntax includes:
 Lists in {...} form. The operators , , and . Function slots in form.
 Various Mathematica operators such as , , , etc.
 Special characters in , , or form.
 String representation of boxes involving , , and other backslash operators.
 Mathematica comments delimited by and .