This is documentation for Mathematica 8, which was
based on an earlier version of the Wolfram Language.
 MATHEMATICA TUTORIAL Related Tutorials »|More About »| Functions »

# Operator Input Forms

Characters that are not letters, letter-like forms, or structural elements are treated by Mathematica as operators. Mathematica has built-in rules for interpreting all operators. The functions to which these operators correspond may or may not, however, have built-in evaluation or other rules. Cases in which built-in meanings are by default defined are indicated by in the tables below.
Operators that construct two-dimensional boxes—all of which have names beginning with backslash—can only be used inside \(...\). The table below gives the interpretations of these operators within "Input of Boxes" gives interpretations when no is included.
 exprandexpri any expression symb any symbol patt any pattern object stringandstringi or a sequence of letters, letter-like forms, and digits filename like string, but can include additional characters described below built-in meanings exist

Objects used in the tables of operator input forms.

### Operator Precedence

operator form
full form
grouping
forms representing numbers (see Numbers)
forms representing symbols (see Symbol Names and Contexts)
forms representing character strings (see Character Strings)
 e11 e12 ... e21 e22 ... ...
{{e11,e12,...},{e21,e22,...},...}
 e11 e12 e21 e22 ...
Piecewise[{{e11,e12},{e21,e22},...}]
expr::stringMessageName[expr,"string"]
expr::string1::string2MessageName[expr,"string1","string2"]
forms containing (see additional input forms)
forms containing (see additional input forms)
forms containing (see additional input forms)
<<filenameGet["filename"]
Overscript[expr1,expr2]
expr1\&expr2Overscript[expr1,expr2]e\&(e\&e)
Underscript[expr1,expr2]
expr1\+expr2Underscript[expr1,expr2]e\+(e\+e)
Underoverscript[expr1,expr2,expr3]
expr1\+expr2\%expr3Underoverscript[expr1,expr2,expr3]
expr1\&expr2\%expr3Underoverscript[expr1,expr3,expr2]
expr1expr2Subscript[expr1,expr2]e(ee)
expr1\_expr2Subscript[expr1,expr2]e\_(e\_e)
expr1\_expr2\%expr3Power[Subscript[expr1,expr2],expr3]
\!boxes(interpreted version of boxes)
expr1?expr2PatternTest[expr1,expr2]
expr1[expr2,...]expr1[expr2,...](e[e])[e]
expr1[[expr2,...]]Part[expr1,expr2,...](e[[e]])[[e]]
expr1expr2,...Part[expr1,expr2,...](ee)e
expr1expr2Part[expr1,expr2,...](ee)e
\*expr(boxes constructed from expr)
expr++Increment[expr]
expr--Decrement[expr]
++exprPreIncrement[expr]
--exprPreDecrement[expr]
expr1@expr2expr1[expr2]e@(e@e)
expr1 expr2(invisible application, input as Esc @ Esc )
expr1[expr2]
expr1~expr2~expr3expr2[expr1,expr3](e~e~e)~e~e
expr1/@expr2Map[expr1,expr2]e/@(e/@e)
expr1//@expr2MapAll[expr1,expr2]e//@(e//@e)
expr1@@expr2Apply[expr1,expr2]e@@(e@@e)
expr1@@@expr2Apply[expr1,expr2,{1}]e@@@(e@@@e)
expr!Factorial[expr]
expr!!Factorial2[expr]
expr*Conjugate[expr]
exprTranspose[expr]
exprConjugateTranspose[expr]
exprConjugateTranspose[expr]
expr'Derivative[1][expr]
expr''...' (n times)Derivative[n][expr]
expr1<>expr2<>expr3StringJoin[expr1,expr2,expr3]e<>e<>e
expr1^expr2Power[expr1,expr2]e^(e^e)
expr1expr2Power[expr1,expr2]e(ee)
Power[Subscript[expr1,expr2],expr3]
expr1\^expr2\%expr3Power[Subscript[expr1,expr3],expr2]
vertical arrow and vector operators
Sqrt[expr]
\@ exprSqrt[expr]\@(\@ e)
\@ expr\%nPower[expr,1/n]
expr1 expr2Integrate[expr1,expr2] ( e e) e
e3e4Integrate[e3,{e4,e1,e2}] ( e e) e
other integration operators
expr1expr2D[expr2,expr1]e(ee)
exprDel[expr](e)
expr1expr2DiscreteShift[expr2,expr1]e(ee)
expr1expr2DiscreteRatio[expr2,expr1]e(ee)
expr1expr2DifferenceDelta[expr2,expr1]e(ee)
exprSquare[expr]( e)
expr1 expr2 expr3SmallCircle[expr1,expr2,expr3]e e e
expr1 expr2 expr3CircleDot[expr1,expr2,expr3]e e e
expr1**expr2**expr3NonCommutativeMultiply[expr1,expr2,expr3]e**e**e
expr1expr2expr3Cross[expr1,expr2,expr3]eee
expr1.expr2.expr3Dot[expr1,expr2,expr3]e.e.e
-exprTimes[-1,expr]
+exprexpr
±exprPlusMinus[expr]
exprMinusPlus[expr]
expr1/expr2expr1(expr2)^-1(e/e)/e
expr1÷expr2Divide[expr1,expr2](e÷ee
expr1\/expr2Divide[expr1,expr2](e\/e)\/e
expr1\expr2\expr3Backslash[expr1,expr2,expr3]e\e\e
expr1expr2expr3Diamond[expr1,expr2,expr3]eee
expr1expr2expr3Wedge[expr1,expr2,expr3]eee
expr1expr2expr3Vee[expr1,expr2,expr3]eee
expr1expr2expr3CircleTimes[expr1,expr2,expr3]eee
expr1expr2expr3CenterDot[expr1,expr2,expr3]eee
expr1 expr2 expr3Times[expr1,expr2,expr3]e e e
expr1*expr2*expr3Times[expr1,expr2,expr3]e*e*e
expr1×expr2×expr3Times[expr1,expr2,expr3]e×e×e
expr1expr2expr3Star[expr1,expr2,expr3]eee
e4Product[e4,{e1,e2,e3}]( e)
expr1expr2expr3VerticalTilde[expr1,expr2,expr3]eee
expr1expr2expr3Coproduct[expr1,expr2,expr3]eee
expr1expr2expr3Cap[expr1,expr2,expr3]eee
expr1expr2expr3Cup[expr1,expr2,expr3]eee
expr1 expr2 expr3CirclePlus[expr1,expr2,expr3]eee
expr1 expr2CircleMinus[expr1,expr2](e e) e
e4Sum[e4,{e1,e2,e3}]( e)
expr1+expr2+expr3Plus[expr1,expr2,expr3]e+e+e
expr1-expr2expr1+(-1expr2)(e-e)-e
expr1±expr2PlusMinus[expr1,expr2](e±ee
expr1expr2MinusPlus[expr1,expr2](ee)e
expr1expr2Intersection[expr1,expr2]eee
other intersection operators
expr1expr2Union[expr1,expr2]eee
other union operators
i;;j;;kSpan[i,j,k]e;;e;;e
expr1==expr2Equal[expr1,expr2]e==e==e
expr1==expr2Equal[expr1,expr2]e==e==e
expr1expr2Equal[expr1,expr2]eee
expr1!= expr2Unequal[expr1,expr2]e!=e!=e
expr1!=expr2Unequal[expr1,expr2]e!=e!=e
other equality and similarity operators
expr1>expr2Greater[expr1,expr2]e>e>e
expr1>=expr2GreaterEqual[expr1,expr2]e>=e>=e
expr1expr2GreaterEqual[expr1,expr2]eee
expr1expr2GreaterEqual[expr1,expr2]eee
expr1<expr2Less[expr1,expr2]e<e<e
expr1<=expr2LessEqual[expr1,expr2]e<=e<=e
expr1expr2LessEqual[expr1,expr2]eee
expr1expr2LessEqual[expr1,expr2]eee
other ordering operators
expr1|expr2VerticalBar[expr1,expr2]e|e|e
expr1expr2NotVerticalBar[expr1,expr2]eee
expr1expr2DoubleVerticalBar[expr1,expr2]eee
expr1expr2NotDoubleVerticalBar[expr1,expr2]eee
horizontal arrow and vector operators
diagonal arrow operators
expr1===expr2SameQ[expr1,expr2]e===e===e
expr1=!=expr2UnsameQ[expr1,expr2]e=!=e=!=e
expr1expr2Element[expr1,expr2]eee
expr1expr2NotElement[expr1,expr2]eee
expr1expr2Subset[expr1,expr2]eee
expr1expr2Superset[expr1,expr2]eee
other set relation operators
expr1expr2ForAll[expr1,expr2]e(ee)
expr1expr2Exists[expr1,expr2]e(ee)
expr1expr2NotExists[expr1,expr2]e(ee)
!exprNot[expr]!(!e)
¬exprNot[expr]¬(¬e)
expr1&&expr2&&expr3And[expr1,expr2,expr3]e&&e&&e
expr1expr2expr3And[expr1,expr2,expr3]eee
expr1expr2expr3Nand[expr1,expr2,expr3]eee
expr1expr2expr3Xor[expr1,expr2,expr3]eee
expr1expr2expr3Xnor[expr1,expr2,expr3]eee
expr1||expr2||expr3Or[expr1,expr2,expr3]e||e||e
expr1expr2expr3Or[expr1,expr2,expr3]eee
expr1expr2expr3Nor[expr1,expr2,expr3]eee
expr1expr2expr3Equivalent[expr1,expr2,expr3]eee
expr1expr2Implies[expr1,expr2]e(ee)
expr1expr2Implies[expr1,expr2]eee
expr1expr2RightTee[expr1,expr2]e(ee)
expr1expr2DoubleRightTee[expr1,expr2]e(ee)
expr1expr2LeftTee[expr1,expr2](ee)e
expr1expr2DoubleLeftTee[expr1,expr2](ee)e
expr1expr2SuchThat[expr1,expr2]e(ee)
expr..Repeated[expr]
expr...RepeatedNull[expr]
expr1|expr2Alternatives[expr1,expr2]e|e|e
symb:exprPattern[symb,expr]
patt:exprOptional[patt,expr]
expr1~~expr2~~expr3StringExpression[expr1,expr2,expr3]e~~e~~e
expr1/;expr2Condition[expr1,expr2](e/;e)/;e
expr1->expr2Rule[expr1,expr2]e->(e->e)
expr1expr2Rule[expr1,expr2]e→(ee)
expr1:>expr2RuleDelayed[expr1,expr2]e:>(e:>e)
expr1expr2RuleDelayed[expr1,expr2]e⧴(ee)
expr1/.expr2ReplaceAll[expr1,expr2](e/.e)/.e
expr1//.expr2ReplaceRepeated[expr1,expr2](e//.e)//.e
expr1-=expr2SubtractFrom[expr1,expr2]e-=(e-=e)
expr1*=expr2TimesBy[expr1,expr2]e*=(e*=e)
expr1/=expr2DivideBy[expr1,expr2]e/=(e/=e)
expr&Function[expr]
expr1:expr2Colon[expr1:expr2]e:e:e
expr1//expr2expr2[expr1](e//e)//e
expr1expr2VerticalSeparator[expr1,expr2]eee
expr1expr2Therefore[expr1,expr2]e(ee)
expr1expr2Because[expr1,expr2](ee)e
expr1=expr2Set[expr1,expr2]e=(e=e)
expr1:=expr2SetDelayed[expr1,expr2]e:=(e:=e)
expr1^=expr2UpSet[expr1,expr2]e^=(e^=e)
expr1^:=expr2UpSetDelayed[expr1,expr2]e^:=(e^:=e)
symb/:expr1=expr2TagSet[symb,expr1,expr2]
symb/:expr1:=expr2TagSetDelayed[symb,expr1,expr2]
expr=.Unset[expr]
symb/:expr=.TagUnset[symb,expr]
expr1expr2Function[{expr1},expr2]e(ee)
expr>>filenamePut[expr,"filename"]
expr>>>filenamePutAppend[expr,"filename"]
expr1;expr2;expr3CompoundExpression[expr1,expr2,expr3]
expr1;expr2;CompoundExpression[expr1,expr2,Null]
expr1\`expr2FormBox[expr2,expr1]e\`(e\`e)

Operator input forms, in order of decreasing precedence.

 special input form full form # Slot[1] #n Slot[n] ## SlotSequence[1] ##n SlotSequence[n] % Out[ ] %% Out[-2] %%...% (n times) Out[-n] %n Out[n] _ Blank[ ] _expr Blank[expr] __ BlankSequence[ ] __expr BlankSequence[expr] ___ BlankNullSequence[ ] ___expr BlankNullSequence[expr] _. Optional[Blank[ ]] symb_ Pattern[symb,Blank[ ]] symb_expr Pattern[symb,Blank[expr]] symb__ Pattern[symb,BlankSequence[ ]] symb__expr Pattern[symb,BlankSequence[expr]] symb___ Pattern[symb,BlankNullSequence[ ]] symb___expr Pattern[symb,BlankNullSequence[expr]] symb_. Optional[Pattern[symb,Blank[ ]]]

Additional input forms, in order of decreasing precedence.

### Special Characters

Special characters that appear in operators usually have names that correspond to the names of the functions they represent. Thus the character has the name \[CirclePlus] and yields the function CirclePlus. Exceptions are \[GreaterSlantEqual], \[LessSlantEqual] and \[RoundImplies].
The delimiters in matchfix operators have names and .
"Listing of Named Characters" gives a complete listing of special characters that appear in operators.
 keyboard characters special character -> \[Rule] :> \[RuleDelayed] == \[Equal] != \[NotEqual]
 keyboard characters special character >= \[GreaterEqual] >= \[GreaterSlantEqual] <= \[LessEqual] <= \[LessSlantEqual]

Keyboard and special characters with the same interpretations.

 keyboard character special character \[RawColon] : \[Colon] \[RawTilde] ~ \[Tilde] \[RawWedge] ^ \[Wedge] \[RawWedge] ^ \[And] \[RawStar] * \[Star] \[RawBackslash] \ \[Backslash]
 keyboard character special character \[RawDot] . \[CenterDot] \[RawVerticalBar] | \[VerticalBar] \[RawVerticalBar] | \[VerticalSeparator] \[RawVerticalBar] | \[LeftBracketingBar] \[RawDash] - \[Dash] ... \[Ellipsis] ...

Some keyboard and special characters with different interpretations.

### Precedence and the Ordering of Input Forms

The tables of input forms are arranged in decreasing order of precedence. Input forms in the same box have the same precedence. Each page in the table begins a new box. As discussed in "Special Ways to Input Expressions", precedence determines how Mathematica groups terms in input expressions. The general rule is that if has higher precedence than , then is interpreted as , and is interpreted as .

### Grouping of Input Forms

The third columns in the tables show how multiple occurrences of a single input form, or of several input forms with the same precedence, are grouped. For example, is grouped as ("left associative"), while is grouped as ("right associative"). No grouping is needed in an expression like , since Plus is fully associative, as represented by the attribute Flat.

### Precedence of Integration Operators

Forms such as have an "outer" precedence just below Power, as indicated in the table above, but an "inner" precedence just above . The outer precedence determines when needs to be parenthesized; the inner precedence determines when needs to be parenthesized.
See "Two-Dimensional Input Forms" for two-dimensional input forms associated with integration operators.

### Spaces and Multiplication

Spaces in Mathematica denote multiplication, just as they do in standard mathematical notation. In addition, Mathematica takes complete expressions that are adjacent, not necessarily separated by spaces, to be multiplied together.
 • x y z x*y*z • 2x 2*x • 2(x+1) 2*(x+1) • c(x+1) c*(x+1) • (x+1)(y+2) (x+1)*(y+2) • x! y x!*y • x!y x!*y

Alternative forms for multiplication.

An expression like could potentially mean either or . The first interpretation is chosen because Factorial has higher precedence than Not.
Spaces within single input forms are ignored. Thus, for example, is equivalent to . You will often want to insert spaces around lower precedence operators to improve readability.
You can give a "coefficient" for a symbol by preceding it with any sequence of digits. When you use numbers in bases larger than 10, the digits can include letters. (In bases other than 10, there must be a space between the end of the coefficient and the beginning of the symbol name.)
 • , like , means • , like , means • is a single symbol, not

Some cases to be careful about.

### Spaces to Avoid

You should avoid inserting any spaces between the different characters in composite operators such as , , and . Although in some cases such spaces are allowed, they are liable to lead to confusion.
Another case where spaces must be avoided is between the characters of the pattern object . If you type , Mathematica will interpret this as , rather than the single named pattern object .
Similarly, you should not insert any spaces inside pattern objects like .

### Spacing Characters

 • Ordinary keyboard space (\[RawSpace])

Spacing characters equivalent to an ordinary keyboard space.

### Relational Operators

Relational operators can be mixed. An expression like is converted to Inequality[a, Greater, b, GreaterEqual, c], which effectively evaluates as . (The reason for the intermediate form is that it prevents objects from being evaluated twice when input like is processed.)

### File Names

Any file name can be given in quotes after , , and . File names can also be given without quotes if they contain only alphanumeric characters, special characters, and the characters , , , , , , , , , , , and , together with matched pairs of square brackets enclosing any characters other than spaces, tabs, and newlines. Note that file names given without quotes can be followed only by spaces, tabs, or newlines, or by the characters , , or , as well as semicolons and commas.