Products
  • Wolfram|One

    The definitive Wolfram Language and notebook experience

  • Mathematica

    The original technical computing environment

  • Wolfram Notebook Assistant + LLM Kit

    All-in-one AI assistance for your Wolfram experience

  • System Modeler
  • Wolfram Player
  • Finance Platform
  • Wolfram Engine
  • Enterprise Private Cloud
  • Application Server
  • Wolfram|Alpha Notebook Edition
  • Wolfram Cloud App
  • Wolfram Player App

More mobile apps

Core Technologies of Wolfram Products

  • Wolfram Language
  • Computable Data
  • Wolfram Notebooks
  • AI & Linguistic Understanding

Deployment Options

  • Wolfram Cloud
  • wolframscript
  • Wolfram Engine Community Edition
  • Wolfram LLM API
  • WSTPServer
  • Wolfram|Alpha APIs

From the Community

  • Function Repository
  • Community Paclet Repository
  • Example Repository
  • Neural Net Repository
  • Prompt Repository
  • Wolfram Demonstrations
  • Data Repository
  • Group & Organizational Licensing
  • All Products
Consulting & Solutions

We deliver solutions for the AI era—combining symbolic computation, data-driven insights and deep technical expertise

  • Data & Computational Intelligence
  • Model-Based Design
  • Algorithm Development
  • Wolfram|Alpha for Business
  • Blockchain Technology
  • Education Technology
  • Quantum Computation

WolframConsulting.com

Wolfram Solutions

  • Data Science
  • Artificial Intelligence
  • Biosciences
  • Healthcare Intelligence
  • Sustainable Energy
  • Control Systems
  • Enterprise Wolfram|Alpha
  • Blockchain Labs

More Wolfram Solutions

Wolfram Solutions For Education

  • Research Universities
  • Colleges & Teaching Universities
  • Junior & Community Colleges
  • High Schools
  • Educational Technology
  • Computer-Based Math

More Solutions for Education

  • Contact Us
Learning & Support

Get Started

  • Wolfram Language Introduction
  • Fast Intro for Programmers
  • Fast Intro for Math Students
  • Wolfram Language Documentation

More Learning

  • Highlighted Core Areas
  • Demonstrations
  • YouTube
  • Daily Study Groups
  • Wolfram Schools and Programs
  • Books

Grow Your Skills

  • Wolfram U

    Courses in computing, science, life and more

  • Community

    Learn, solve problems and share ideas.

  • Blog

    News, views and insights from Wolfram

  • Resources for

    Software Developers

Tech Support

  • Contact Us
  • Support FAQs
  • Support FAQs
  • Contact Us
Company
  • About Wolfram
  • Career Center
  • All Sites & Resources
  • Connect & Follow
  • Contact Us

Work with Us

  • Student Ambassador Initiative
  • Wolfram for Startups
  • Student Opportunities
  • Jobs Using Wolfram Language

Educational Programs for Adults

  • Summer School
  • Winter School

Educational Programs for Youth

  • Middle School Camp
  • High School Research Program
  • Computational Adventures

Read

  • Stephen Wolfram's Writings
  • Wolfram Blog
  • Wolfram Tech | Books
  • Wolfram Media
  • Complex Systems

Educational Resources

  • Wolfram MathWorld
  • Wolfram in STEM/STEAM
  • Wolfram Challenges
  • Wolfram Problem Generator

Wolfram Initiatives

  • Wolfram Science
  • Wolfram Foundation
  • History of Mathematics Project

Events

  • Stephen Wolfram Livestreams
  • Online & In-Person Events
  • Contact Us
  • Connect & Follow
Wolfram|Alpha
  • Your Account
  • User Portal
  • Wolfram Cloud
  • Products
    • Wolfram|One
    • Mathematica
    • Wolfram Notebook Assistant + LLM Kit
    • System Modeler
    • Wolfram Player
    • Finance Platform
    • Wolfram|Alpha Notebook Edition
    • Wolfram Engine
    • Enterprise Private Cloud
    • Application Server
    • Wolfram Cloud App
    • Wolfram Player App

    More mobile apps

    • Core Technologies
      • Wolfram Language
      • Computable Data
      • Wolfram Notebooks
      • AI & Linguistic Understanding
    • Deployment Options
      • Wolfram Cloud
      • wolframscript
      • Wolfram Engine Community Edition
      • Wolfram LLM API
      • WSTPServer
      • Wolfram|Alpha APIs
    • From the Community
      • Function Repository
      • Community Paclet Repository
      • Example Repository
      • Neural Net Repository
      • Prompt Repository
      • Wolfram Demonstrations
      • Data Repository
    • Group & Organizational Licensing
    • All Products
  • Consulting & Solutions

    We deliver solutions for the AI era—combining symbolic computation, data-driven insights and deep technical expertise

    WolframConsulting.com

    Wolfram Solutions

    • Data Science
    • Artificial Intelligence
    • Biosciences
    • Healthcare Intelligence
    • Sustainable Energy
    • Control Systems
    • Enterprise Wolfram|Alpha
    • Blockchain Labs

    More Wolfram Solutions

    Wolfram Solutions For Education

    • Research Universities
    • Colleges & Teaching Universities
    • Junior & Community Colleges
    • High Schools
    • Educational Technology
    • Computer-Based Math

    More Solutions for Education

    • Contact Us
  • Learning & Support

    Get Started

    • Wolfram Language Introduction
    • Fast Intro for Programmers
    • Fast Intro for Math Students
    • Wolfram Language Documentation

    Grow Your Skills

    • Wolfram U

      Courses in computing, science, life and more

    • Community

      Learn, solve problems and share ideas.

    • Blog

      News, views and insights from Wolfram

    • Resources for

      Software Developers
    • Tech Support
      • Contact Us
      • Support FAQs
    • More Learning
      • Highlighted Core Areas
      • Demonstrations
      • YouTube
      • Daily Study Groups
      • Wolfram Schools and Programs
      • Books
    • Support FAQs
    • Contact Us
  • Company
    • About Wolfram
    • Career Center
    • All Sites & Resources
    • Connect & Follow
    • Contact Us

    Work with Us

    • Student Ambassador Initiative
    • Wolfram for Startups
    • Student Opportunities
    • Jobs Using Wolfram Language

    Educational Programs for Adults

    • Summer School
    • Winter School

    Educational Programs for Youth

    • Middle School Camp
    • High School Research Program
    • Computational Adventures

    Read

    • Stephen Wolfram's Writings
    • Wolfram Blog
    • Wolfram Tech | Books
    • Wolfram Media
    • Complex Systems
    • Educational Resources
      • Wolfram MathWorld
      • Wolfram in STEM/STEAM
      • Wolfram Challenges
      • Wolfram Problem Generator
    • Wolfram Initiatives
      • Wolfram Science
      • Wolfram Foundation
      • History of Mathematics Project
    • Events
      • Stephen Wolfram Livestreams
      • Online & In-Person Events
    • Contact Us
    • Connect & Follow
  • Wolfram|Alpha
  • Wolfram Cloud
  • Your Account
  • User Portal
Wolfram Language & System Documentation Center
Operator Input Forms
TECH NOTE

Operator Input Forms

Characters that are not letters, letter‐like forms, or structural elements are treated by the Wolfram Language as operators. The Wolfram Language 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.
expr
and
expri
any expression
symb
any symbol
patt
any pattern object
string
and
stringi
"cccc" 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 )
⊲
e11e12…
e21e22…
…
{{e11,e12,…},{e21,e22,…},…}⊲

e11e12
e21e22
…
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]]⊲
expr1〚expr2,…〛Part[expr1,expr2,…](e〚e〛)〚e〛⊲
expr1〚expr2〛Part[expr1,expr2,…](e〚e〛)〚e〛⊲
expr1::[expr2,…]TypeSpecifier[expr1][expr2,…](e::[e])::[e]⊲
\*expr
(boxes constructed from expr )
expr++Increment[expr]⊲
expr--Decrement[expr]⊲
++exprPreIncrement[expr]⊲
--exprPreDecrement[expr]⊲
expr1@*expr2Composition[expr1,expr2]e@*e@*e⊲
expr1/*expr2RightComposition[expr1,expr2]e/*e/*e⊲
expr1expr2Application[expr1,expr2](ee)e
expr1@expr2expr1[expr2]e@(e@e)⊲
expr1 expr2
(invisible application, input as expr1 Esc@Esc expr2)
⊲
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@@@expr2MapApply[expr1,expr2]e@@@(e@@@e)⊲
expr!Factorial[expr]⊲
expr!!Factorial2[expr]⊲
exprConjugate[expr]⊲
exprTranspose[expr]⊲
exprConjugateTranspose[expr]⊲
exprConjugateTranspose[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]⊲
 exprDifferentialD[expr]( e)⊲
∂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
expr1expr2expr3Cross[expr1,expr2,expr3]eee⊲
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÷e)÷e⊲
expr1\/expr2Divide[expr1,expr2](e\/e)\/e⊲
expr1∖expr2∖expr3Backslash[expr1,expr2,expr3]e∖e∖e
expr1⋄expr2⋄expr3Diamond[expr1,expr2,expr3]e⋄e⋄e
expr1⋀expr2⋀expr3Wedge[expr1,expr2,expr3]e⋀e⋀e
expr1⋁expr2⋁expr3Vee[expr1,expr2,expr3]e⋁e⋁e
expr1⊗expr2⊗expr3CircleTimes[expr1,expr2,expr3]e⊗e⊗e
expr1·expr2·expr3CenterDot[expr1,expr2,expr3]e·e·e
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⊲
expr1⋆expr2⋆expr3Star[expr1,expr2,expr3]e⋆e⋆e
e4Product[e4,{e1,e2,e3}]∏(∏ e)⊲
expr1≀expr2≀expr3VerticalTilde[expr1,expr2,expr3]e≀e≀e
expr1∐expr2∐expr3Coproduct[expr1,expr2,expr3]e∐e∐e
expr1⌢expr2⌢expr3Cap[expr1,expr2,expr3]e⌢e⌢e
expr1⌣expr2⌣expr3Cup[expr1,expr2,expr3]e⌣e⌣e
expr1⊕ expr2⊕ expr3CirclePlus[expr1,expr2,expr3]e⊕e⊕e
expr1⊖ expr2CircleMinus[expr1,expr2](e ⊖ e)⊖ e
∫ expr1expr2Integrate[expr1,expr2]∫ (∫ e e) e⊲
e3e4Integrate[e3,{e4,e1,e2}]∫ (∫ e e) e⊲
∫e1∈e2e3Integrate[e3,e1∈e2]∫ (∫ e)⊲
other integration operators
e4Sum[e4,{e1,e2,e3}]∑(∑ e)⊲
e3Limit[e3,e1e2](e)⊲
e3MaxLimit[e3,e1e2](e)⊲
e3MinLimit[e3,e1e2](e)⊲
expr1+expr2+expr3Plus[expr1,expr2,expr3]e+e+e⊲
expr1-expr2expr1+(-1expr2)e-e-e⊲
expr1±expr2PlusMinus[expr1,expr2](e±e)±e
expr1∓expr2MinusPlus[expr1,expr2](e∓e)∓e
expr1⋂expr2Intersection[expr1,expr2]e⋂e⋂e⊲
other intersection operators
expr1⋃expr2Union[expr1,expr2]e⋃e⋃e⊲
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⊲
expr1expr2Equal[expr1,expr2]eee⊲
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⊲
expr1≥expr2GreaterEqual[expr1,expr2]e≥e≥e⊲
expr1⩾expr2GreaterEqual[expr1,expr2]e⩾e⩾e⊲
expr1<expr2Less[expr1,expr2]e<e<e⊲
expr1<=expr2LessEqual[expr1,expr2]e<=e<=e⊲
expr1≤expr2LessEqual[expr1,expr2]e≤e≤e⊲
expr1⩽expr2LessEqual[expr1,expr2]e⩽e⩽e⊲
other ordering operators
expr1expr2VerticalBar[expr1,expr2]eee
expr1expr2NotVerticalBar[expr1,expr2]eee
expr1∥expr2DoubleVerticalBar[expr1,expr2]e∥e∥e
expr1∦expr2NotDoubleVerticalBar[expr1,expr2]e∦e∦e
horizontal arrow and vector operators
diagonal arrow operators
expr1===expr2SameQ[expr1,expr2]e===e===e⊲
expr1=!=expr2UnsameQ[expr1,expr2]e=!=e=!=e⊲
expr1∈expr2Element[expr1,expr2]e∈e∈e⊲
expr1∉expr2NotElement[expr1,expr2]e∉e∉e⊲
expr1⊂expr2Subset[expr1,expr2]e⊂e⊂e
expr1⊃expr2Superset[expr1,expr2]e⊃e⊃e
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⊲
expr1∧expr2∧expr3And[expr1,expr2,expr3]e∧e∧e⊲
expr1⊼expr2⊼expr3Nand[expr1,expr2,expr3]e⊼e⊼e⊲
expr1⊻expr2⊻expr3Xor[expr1,expr2,expr3]e⊻e⊻e⊲
expr1expr2expr3Xnor[expr1,expr2,expr3]eee⊲
expr1||expr2||expr3Or[expr1,expr2,expr3]e||e||e⊲
expr1∨expr2∨expr3Or[expr1,expr2,expr3]e∨e∨e⊲
expr1⊽expr2⊽expr3Nor[expr1,expr2,expr3]e⊽e⊽e⊲
expr1⧦expr2⧦expr3Equivalent[expr1,expr2,expr3]e⧦e⧦e⊲
expr1expr2Implies[expr1,expr2]e(ee)⊲
expr1⥰expr2Implies[expr1,expr2]e⥰e⥰e⊲
expr1⊢expr2RightTee[expr1,expr2]e⊢(e⊢e)
expr1⊨expr2DoubleRightTee[expr1,expr2]e⊨(e⊨e)
expr1⊣expr2LeftTee[expr1,expr2](e⊣e)⊣e
expr1⫤expr2DoubleLeftTee[expr1,expr2](e⫤e)⫤e
expr1⊥expr2UpTee[expr1,expr2](e⊥e)⊥e
expr1⊤expr2DownTee[expr1,expr2](e⊤e)⊤e
expr1∍expr2SuchThat[expr1,expr2]e∍(e∍e)
expr..Repeated[expr]⊲
expr...RepeatedNull[expr]⊲
expr1|expr2Alternatives[expr1,expr2]e|e|e⊲
symb:exprPattern[symb,expr]⊲
symb:patt:expr Optional[Pattern[symb,patt],expr]⊲
patt:exprOptional[patt,expr]⊲
expr1~~expr2~~expr3StringExpression[expr1,expr2,expr3]e~~e~~e⊲
expr1/;expr2Condition[expr1,expr2](e/;e)/;e⊲
expr1<->expr2TwoWayRule[expr1,expr2]e<->(e<->e)⊲
expr1expr2TwoWayRule[expr1,expr2]e(ee)⊲
expr1expr2Rule[expr1,expr2]e(ee)⊲
expr1expr2Rule[expr1,expr2]e(ee)⊲
expr1:>expr2RuleDelayed[expr1,expr2]e:>(e:>e)⊲
expr1 expr2RuleDelayed[expr1,expr2]e(ee)⊲
expr1/.expr2ReplaceAll[expr1,expr2](e/.e)/.e⊲
expr1//.expr2ReplaceRepeated[expr1,expr2](e//.e)//.e⊲
expr1+=expr2AddTo[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//=expr2ApplyTo[expr1,expr2]e//=(e//=e)⊲
expr1//expr2expr2[expr1](e//e)//e
expr1expr2VerticalSeparator[expr1,expr2]eee
expr1∴expr2Therefore[expr1,expr2]e∴(e∴e)
expr1∵expr2Because[expr1,expr2](e∵e)∵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]⊲
expr1|->expr2Function[expr1,expr2]e(ee)⊲
expr1expr2Function[expr1,expr2]e(ee)⊲
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. Operators of equal precedence are grouped together.
special input form
full form
#Slot[1]
#nSlot[n]
#stringSlot["string"]
##SlotSequence[1]
##nSlotSequence[n]
%Out[ ]
%%Out[-2]
%%…%
( n times)
Out[-n]
%nOut[n]
_Blank[ ]
_exprBlank[expr]
__BlankSequence[ ]
__exprBlankSequence[expr]
___BlankNullSequence[ ]
___exprBlankNullSequence[expr]
_.Optional[Blank[ ]]
symb_Pattern[symb,Blank[ ]]
symb_exprPattern[symb,Blank[expr]]
symb__Pattern[symb,BlankSequence[ ]]
symb__exprPattern[symb,BlankSequence[expr]]
symb___Pattern[symb,BlankNullSequence[ ]]
symb___exprPattern[symb,BlankNullSequence[expr]]
symb_.Optional[Pattern[symb,Blank[ ]]]
_ :exprOptional[Blank[],expr]
symb_:exprOptional[Pattern[symb,Blank[]],expr]
_head :exprOptional[Blank[head],expr]
symb_head:exprOptional[Pattern[symb,Blank[head]],expr]
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 ⊕ and yields the function CirclePlus. Exceptions are ⩾, ⩽ and ⥰.
The delimiters in matchfix operators have names \[LeftName] and \[RightName].
"Listing of Named Characters" gives a complete listing of special characters that appear in operators.
keyboard characters
special character
-> 
:> 
== 
!=≠ ≠
keyboard characters
special character
>=≥ ≥
>=⩾ ⩾
<=≤ ≤
<=⩽ ⩽
Keyboard and special characters with the same interpretations.
keyboard character
special character
: :∶ ∶
~ ~∼ ∼
^ ^⋀ ⋀
^ ^∧ ∧
* *⋆ ⋆
\ ∖∖ ∖
keyboard character
special character
. .· ·
| | 
| | 
| | 
- -– –
...… …
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 the Wolfram Language 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, a/b/c is grouped as (a/b)/c ("left associative"), while a^b^c is grouped as a^(b^c) ("right associative"). No grouping is needed in an expression like a+b+c, since Plus is fully associative, as represented by the attribute Flat.

Precedence of Integration Operators

Forms such as involve two operators: \[Integral] and \[DifferentialD]. The former has a precedence just above , while the latter has one just below Power. The precedence of determines when needs to be parenthesized, while the precedence of determines when needs to be parenthesized. Note that the form does not involve , and therefore behaves like a normal prefix operator in this case.
∮, ∲ and ∯ work the same as ∫.
See "Two-Dimensional Input Forms" for two‐dimensional input forms associated with integration operators.

Spaces and Multiplication

Spaces in the Wolfram Language denote multiplication, just as they do in standard mathematical notation. In addition, the Wolfram Language 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 x!y could potentially mean either (x!)*y or x*(!y). The first interpretation is chosen because Factorial has higher precedence than Not.
Spaces within single input forms are ignored. Thus, for example, a + b is equivalent to a+b. 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.)
■ x^2y, like x^2 y, means (x^2) y
■ x/2y, like x/2 y, means (x/2) y
■ xy is a single symbol, not x*y
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 x_. If you type x_, the Wolfram Language will interpret this as x*_, rather than the single named pattern object x_.
Similarly, you should not insert any spaces inside pattern objects like x_:value.

Spacing Characters

■ Ordinary keyboard space ( )
■  , , …,  
■ , , …,
■ ␣ (␣)
Spacing characters equivalent to an ordinary keyboard space.

Relational Operators

Relational operators can be mixed. An expression like a>b>=c is converted to Inequality[a,Greater,b,GreaterEqual,c], which effectively evaluates as (a>b)&&(b>=c). (The reason for the intermediate Inequality form is that it prevents objects from being evaluated twice when input like a>b>=c 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 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.

Related Guides

    ▪
  • Syntax

Related Tech Notes

    ▪
  • Input Syntax
Top
Introduction for Programmers
Introductory Book
Wolfram Function Repository | Wolfram Data Repository | Wolfram Data Drop | Wolfram Language Products
Top
  • Products
  • Wolfram|One
  • Mathematica
  • Notebook Assistant + LLM Kit
  • System Modeler

  • Wolfram|Alpha Notebook Edition
  • Wolfram|Alpha Pro
  • Mobile Apps

  • Wolfram Player
  • Wolfram Engine

  • Volume & Site Licensing
  • Server Deployment Options
  • Consulting
  • Wolfram Consulting
  • Repositories
  • Data Repository
  • Function Repository
  • Community Paclet Repository
  • Neural Net Repository
  • Prompt Repository

  • Wolfram Language Example Repository
  • Notebook Archive
  • Wolfram GitHub
  • Learning
  • Wolfram U
  • Wolfram Language Documentation
  • Webinars & Training
  • Educational Programs

  • Wolfram Language Introduction
  • Fast Introduction for Programmers
  • Fast Introduction for Math Students
  • Books

  • Wolfram Community
  • Wolfram Blog
  • Public Resources
  • Wolfram|Alpha
  • Wolfram Problem Generator
  • Wolfram Challenges

  • Computer-Based Math
  • Computational Thinking
  • Computational Adventures

  • Demonstrations Project
  • Wolfram Data Drop
  • MathWorld
  • Wolfram Science
  • Wolfram Media Publishing
  • Customer Resources
  • Store
  • Product Downloads
  • User Portal
  • Your Account
  • Organization Access

  • Support FAQ
  • Contact Support
  • Company
  • About Wolfram
  • Careers
  • Contact
  • Events
Wolfram Community Wolfram Blog
Legal & Privacy Policy
WolframAlpha.com | WolframCloud.com
© 2025 Wolfram
© 2025 Wolfram | Legal & Privacy Policy |
English